// This file has been automatically generated. Do NOT edit edit manually, all your changes will be lost when it is regenerated.

#pragma once

#if !defined(VK_CAPTURE_VARIANT_WRAP_HPP_INCLUDED)
#define VK_CAPTURE_VARIANT_WRAP_HPP_INCLUDED 1

#include <cstring>
#include <type_traits>
#include <vulkan/vulkan.h>
#include "common.hpp"
#include "vk_capture.h"
namespace vk_capture
{

inline void* copyNextPtr(const void* pNext);

// do nothing by default
template<typename T>
inline void copyIndirectData(const T&) {}

inline void copyIndirectData(const char*& value)
{
    const std::size_t len = std::strlen(value) + 1;
    char* copy = allocType<char>(len);
    std::memcpy(copy, value, len);
    value = copy;
}

template<typename TStruct>
inline void copyIndirectData(const TStruct*& value)
{
    TStruct* copy = allocType<TStruct>();
    std::memcpy(copy, value, sizeof(TStruct));
    copyIndirectData(*copy);
    value = copy;
}
inline void copyIndirectData(VkBaseOutStructure& value);
inline void copyIndirectData(VkBaseInStructure& value);
inline void copyIndirectData(VkOffset2D& value);
inline void copyIndirectData(VkOffset3D& value);
inline void copyIndirectData(VkExtent2D& value);
inline void copyIndirectData(VkExtent3D& value);
inline void copyIndirectData(VkViewport& value);
inline void copyIndirectData(VkRect2D& value);
inline void copyIndirectData(VkClearRect& value);
inline void copyIndirectData(VkComponentMapping& value);
inline void copyIndirectData(VkPhysicalDeviceProperties& value);
inline void copyIndirectData(VkExtensionProperties& value);
inline void copyIndirectData(VkLayerProperties& value);
inline void copyIndirectData(VkApplicationInfo& value);
inline void copyIndirectData(VkAllocationCallbacks& value);
inline void copyIndirectData(VkDeviceQueueCreateInfo& value);
inline void copyIndirectData(VkDeviceCreateInfo& value);
inline void copyIndirectData(VkInstanceCreateInfo& value);
inline void copyIndirectData(VkQueueFamilyProperties& value);
inline void copyIndirectData(VkPhysicalDeviceMemoryProperties& value);
inline void copyIndirectData(VkMemoryAllocateInfo& value);
inline void copyIndirectData(VkMemoryRequirements& value);
inline void copyIndirectData(VkSparseImageFormatProperties& value);
inline void copyIndirectData(VkSparseImageMemoryRequirements& value);
inline void copyIndirectData(VkMemoryType& value);
inline void copyIndirectData(VkMemoryHeap& value);
inline void copyIndirectData(VkMappedMemoryRange& value);
inline void copyIndirectData(VkFormatProperties& value);
inline void copyIndirectData(VkImageFormatProperties& value);
inline void copyIndirectData(VkDescriptorBufferInfo& value);
inline void copyIndirectData(VkDescriptorImageInfo& value);
inline void copyIndirectData(VkWriteDescriptorSet& value);
inline void copyIndirectData(VkCopyDescriptorSet& value);
inline void copyIndirectData(VkBufferCreateInfo& value);
inline void copyIndirectData(VkBufferViewCreateInfo& value);
inline void copyIndirectData(VkImageSubresource& value);
inline void copyIndirectData(VkImageSubresourceLayers& value);
inline void copyIndirectData(VkImageSubresourceRange& value);
inline void copyIndirectData(VkMemoryBarrier& value);
inline void copyIndirectData(VkBufferMemoryBarrier& value);
inline void copyIndirectData(VkImageMemoryBarrier& value);
inline void copyIndirectData(VkImageCreateInfo& value);
inline void copyIndirectData(VkSubresourceLayout& value);
inline void copyIndirectData(VkImageViewCreateInfo& value);
inline void copyIndirectData(VkBufferCopy& value);
inline void copyIndirectData(VkSparseMemoryBind& value);
inline void copyIndirectData(VkSparseImageMemoryBind& value);
inline void copyIndirectData(VkSparseBufferMemoryBindInfo& value);
inline void copyIndirectData(VkSparseImageOpaqueMemoryBindInfo& value);
inline void copyIndirectData(VkSparseImageMemoryBindInfo& value);
inline void copyIndirectData(VkBindSparseInfo& value);
inline void copyIndirectData(VkImageCopy& value);
inline void copyIndirectData(VkImageBlit& value);
inline void copyIndirectData(VkBufferImageCopy& value);
inline void copyIndirectData(VkImageResolve& value);
inline void copyIndirectData(VkShaderModuleCreateInfo& value);
inline void copyIndirectData(VkDescriptorSetLayoutBinding& value);
inline void copyIndirectData(VkDescriptorSetLayoutCreateInfo& value);
inline void copyIndirectData(VkDescriptorPoolSize& value);
inline void copyIndirectData(VkDescriptorPoolCreateInfo& value);
inline void copyIndirectData(VkDescriptorSetAllocateInfo& value);
inline void copyIndirectData(VkSpecializationMapEntry& value);
inline void copyIndirectData(VkSpecializationInfo& value);
inline void copyIndirectData(VkPipelineShaderStageCreateInfo& value);
inline void copyIndirectData(VkComputePipelineCreateInfo& value);
inline void copyIndirectData(VkVertexInputBindingDescription& value);
inline void copyIndirectData(VkVertexInputAttributeDescription& value);
inline void copyIndirectData(VkPipelineVertexInputStateCreateInfo& value);
inline void copyIndirectData(VkPipelineInputAssemblyStateCreateInfo& value);
inline void copyIndirectData(VkPipelineTessellationStateCreateInfo& value);
inline void copyIndirectData(VkPipelineViewportStateCreateInfo& value);
inline void copyIndirectData(VkPipelineRasterizationStateCreateInfo& value);
inline void copyIndirectData(VkPipelineMultisampleStateCreateInfo& value);
inline void copyIndirectData(VkPipelineColorBlendAttachmentState& value);
inline void copyIndirectData(VkPipelineColorBlendStateCreateInfo& value);
inline void copyIndirectData(VkPipelineDynamicStateCreateInfo& value);
inline void copyIndirectData(VkStencilOpState& value);
inline void copyIndirectData(VkPipelineDepthStencilStateCreateInfo& value);
inline void copyIndirectData(VkGraphicsPipelineCreateInfo& value);
inline void copyIndirectData(VkPipelineCacheCreateInfo& value);
inline void copyIndirectData(VkPipelineCacheHeaderVersionOne& value);
inline void copyIndirectData(VkPushConstantRange& value);
inline void copyIndirectData(VkPipelineLayoutCreateInfo& value);
inline void copyIndirectData(VkSamplerCreateInfo& value);
inline void copyIndirectData(VkCommandPoolCreateInfo& value);
inline void copyIndirectData(VkCommandBufferAllocateInfo& value);
inline void copyIndirectData(VkCommandBufferInheritanceInfo& value);
inline void copyIndirectData(VkCommandBufferBeginInfo& value);
inline void copyIndirectData(VkRenderPassBeginInfo& value);
inline void copyIndirectData(VkClearDepthStencilValue& value);
inline void copyIndirectData(VkClearAttachment& value);
inline void copyIndirectData(VkAttachmentDescription& value);
inline void copyIndirectData(VkAttachmentReference& value);
inline void copyIndirectData(VkSubpassDescription& value);
inline void copyIndirectData(VkSubpassDependency& value);
inline void copyIndirectData(VkRenderPassCreateInfo& value);
inline void copyIndirectData(VkEventCreateInfo& value);
inline void copyIndirectData(VkFenceCreateInfo& value);
inline void copyIndirectData(VkPhysicalDeviceFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceSparseProperties& value);
inline void copyIndirectData(VkPhysicalDeviceLimits& value);
inline void copyIndirectData(VkSemaphoreCreateInfo& value);
inline void copyIndirectData(VkQueryPoolCreateInfo& value);
inline void copyIndirectData(VkFramebufferCreateInfo& value);
inline void copyIndirectData(VkDrawIndirectCommand& value);
inline void copyIndirectData(VkDrawIndexedIndirectCommand& value);
inline void copyIndirectData(VkDispatchIndirectCommand& value);
inline void copyIndirectData(VkMultiDrawInfoEXT& value);
inline void copyIndirectData(VkMultiDrawIndexedInfoEXT& value);
inline void copyIndirectData(VkSubmitInfo& value);
inline void copyIndirectData(VkDisplayPropertiesKHR& value);
inline void copyIndirectData(VkDisplayPlanePropertiesKHR& value);
inline void copyIndirectData(VkDisplayModeParametersKHR& value);
inline void copyIndirectData(VkDisplayModePropertiesKHR& value);
inline void copyIndirectData(VkDisplayModeCreateInfoKHR& value);
inline void copyIndirectData(VkDisplayPlaneCapabilitiesKHR& value);
inline void copyIndirectData(VkDisplaySurfaceCreateInfoKHR& value);
inline void copyIndirectData(VkDisplayPresentInfoKHR& value);
inline void copyIndirectData(VkSurfaceCapabilitiesKHR& value);
inline void copyIndirectData(VkSurfaceFormatKHR& value);
inline void copyIndirectData(VkSwapchainCreateInfoKHR& value);
inline void copyIndirectData(VkPresentInfoKHR& value);
inline void copyIndirectData(VkDebugReportCallbackCreateInfoEXT& value);
inline void copyIndirectData(VkValidationFlagsEXT& value);
inline void copyIndirectData(VkValidationFeaturesEXT& value);
inline void copyIndirectData(VkPipelineRasterizationStateRasterizationOrderAMD& value);
inline void copyIndirectData(VkDebugMarkerObjectNameInfoEXT& value);
inline void copyIndirectData(VkDebugMarkerObjectTagInfoEXT& value);
inline void copyIndirectData(VkDebugMarkerMarkerInfoEXT& value);
inline void copyIndirectData(VkDedicatedAllocationImageCreateInfoNV& value);
inline void copyIndirectData(VkDedicatedAllocationBufferCreateInfoNV& value);
inline void copyIndirectData(VkDedicatedAllocationMemoryAllocateInfoNV& value);
inline void copyIndirectData(VkExternalImageFormatPropertiesNV& value);
inline void copyIndirectData(VkExternalMemoryImageCreateInfoNV& value);
inline void copyIndirectData(VkExportMemoryAllocateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& value);
inline void copyIndirectData(VkDevicePrivateDataCreateInfo& value);
inline void copyIndirectData(VkPrivateDataSlotCreateInfo& value);
inline void copyIndirectData(VkPhysicalDevicePrivateDataFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& value);
inline void copyIndirectData(VkPhysicalDeviceMultiDrawPropertiesEXT& value);
inline void copyIndirectData(VkGraphicsShaderGroupCreateInfoNV& value);
inline void copyIndirectData(VkGraphicsPipelineShaderGroupsCreateInfoNV& value);
inline void copyIndirectData(VkBindShaderGroupIndirectCommandNV& value);
inline void copyIndirectData(VkBindIndexBufferIndirectCommandNV& value);
inline void copyIndirectData(VkBindVertexBufferIndirectCommandNV& value);
inline void copyIndirectData(VkSetStateFlagsIndirectCommandNV& value);
inline void copyIndirectData(VkIndirectCommandsStreamNV& value);
inline void copyIndirectData(VkIndirectCommandsLayoutTokenNV& value);
inline void copyIndirectData(VkIndirectCommandsLayoutCreateInfoNV& value);
inline void copyIndirectData(VkGeneratedCommandsInfoNV& value);
inline void copyIndirectData(VkGeneratedCommandsMemoryRequirementsInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceFeatures2& value);
inline void copyIndirectData(VkPhysicalDeviceProperties2& value);
inline void copyIndirectData(VkFormatProperties2& value);
inline void copyIndirectData(VkImageFormatProperties2& value);
inline void copyIndirectData(VkPhysicalDeviceImageFormatInfo2& value);
inline void copyIndirectData(VkQueueFamilyProperties2& value);
inline void copyIndirectData(VkPhysicalDeviceMemoryProperties2& value);
inline void copyIndirectData(VkSparseImageFormatProperties2& value);
inline void copyIndirectData(VkPhysicalDeviceSparseImageFormatInfo2& value);
inline void copyIndirectData(VkPhysicalDevicePushDescriptorPropertiesKHR& value);
inline void copyIndirectData(VkConformanceVersion& value);
inline void copyIndirectData(VkPhysicalDeviceDriverProperties& value);
inline void copyIndirectData(VkPresentRegionsKHR& value);
inline void copyIndirectData(VkPresentRegionKHR& value);
inline void copyIndirectData(VkRectLayerKHR& value);
inline void copyIndirectData(VkPhysicalDeviceVariablePointersFeatures& value);
inline void copyIndirectData(VkExternalMemoryProperties& value);
inline void copyIndirectData(VkPhysicalDeviceExternalImageFormatInfo& value);
inline void copyIndirectData(VkExternalImageFormatProperties& value);
inline void copyIndirectData(VkPhysicalDeviceExternalBufferInfo& value);
inline void copyIndirectData(VkExternalBufferProperties& value);
inline void copyIndirectData(VkPhysicalDeviceIDProperties& value);
inline void copyIndirectData(VkExternalMemoryImageCreateInfo& value);
inline void copyIndirectData(VkExternalMemoryBufferCreateInfo& value);
inline void copyIndirectData(VkExportMemoryAllocateInfo& value);
inline void copyIndirectData(VkImportMemoryFdInfoKHR& value);
inline void copyIndirectData(VkMemoryFdPropertiesKHR& value);
inline void copyIndirectData(VkMemoryGetFdInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceExternalSemaphoreInfo& value);
inline void copyIndirectData(VkExternalSemaphoreProperties& value);
inline void copyIndirectData(VkExportSemaphoreCreateInfo& value);
inline void copyIndirectData(VkImportSemaphoreFdInfoKHR& value);
inline void copyIndirectData(VkSemaphoreGetFdInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceExternalFenceInfo& value);
inline void copyIndirectData(VkExternalFenceProperties& value);
inline void copyIndirectData(VkExportFenceCreateInfo& value);
inline void copyIndirectData(VkImportFenceFdInfoKHR& value);
inline void copyIndirectData(VkFenceGetFdInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceMultiviewFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceMultiviewProperties& value);
inline void copyIndirectData(VkRenderPassMultiviewCreateInfo& value);
inline void copyIndirectData(VkSurfaceCapabilities2EXT& value);
inline void copyIndirectData(VkDisplayPowerInfoEXT& value);
inline void copyIndirectData(VkDeviceEventInfoEXT& value);
inline void copyIndirectData(VkDisplayEventInfoEXT& value);
inline void copyIndirectData(VkSwapchainCounterCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceGroupProperties& value);
inline void copyIndirectData(VkMemoryAllocateFlagsInfo& value);
inline void copyIndirectData(VkBindBufferMemoryInfo& value);
inline void copyIndirectData(VkBindBufferMemoryDeviceGroupInfo& value);
inline void copyIndirectData(VkBindImageMemoryInfo& value);
inline void copyIndirectData(VkBindImageMemoryDeviceGroupInfo& value);
inline void copyIndirectData(VkDeviceGroupRenderPassBeginInfo& value);
inline void copyIndirectData(VkDeviceGroupCommandBufferBeginInfo& value);
inline void copyIndirectData(VkDeviceGroupSubmitInfo& value);
inline void copyIndirectData(VkDeviceGroupBindSparseInfo& value);
inline void copyIndirectData(VkDeviceGroupPresentCapabilitiesKHR& value);
inline void copyIndirectData(VkImageSwapchainCreateInfoKHR& value);
inline void copyIndirectData(VkBindImageMemorySwapchainInfoKHR& value);
inline void copyIndirectData(VkAcquireNextImageInfoKHR& value);
inline void copyIndirectData(VkDeviceGroupPresentInfoKHR& value);
inline void copyIndirectData(VkDeviceGroupDeviceCreateInfo& value);
inline void copyIndirectData(VkDeviceGroupSwapchainCreateInfoKHR& value);
inline void copyIndirectData(VkDescriptorUpdateTemplateEntry& value);
inline void copyIndirectData(VkDescriptorUpdateTemplateCreateInfo& value);
inline void copyIndirectData(VkXYColorEXT& value);
inline void copyIndirectData(VkPhysicalDevicePresentIdFeaturesKHR& value);
inline void copyIndirectData(VkPresentIdKHR& value);
inline void copyIndirectData(VkPhysicalDevicePresentWaitFeaturesKHR& value);
inline void copyIndirectData(VkHdrMetadataEXT& value);
inline void copyIndirectData(VkDisplayNativeHdrSurfaceCapabilitiesAMD& value);
inline void copyIndirectData(VkSwapchainDisplayNativeHdrCreateInfoAMD& value);
inline void copyIndirectData(VkRefreshCycleDurationGOOGLE& value);
inline void copyIndirectData(VkPastPresentationTimingGOOGLE& value);
inline void copyIndirectData(VkPresentTimesInfoGOOGLE& value);
inline void copyIndirectData(VkPresentTimeGOOGLE& value);
inline void copyIndirectData(VkViewportWScalingNV& value);
inline void copyIndirectData(VkPipelineViewportWScalingStateCreateInfoNV& value);
inline void copyIndirectData(VkViewportSwizzleNV& value);
inline void copyIndirectData(VkPipelineViewportSwizzleStateCreateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceDiscardRectanglePropertiesEXT& value);
inline void copyIndirectData(VkPipelineDiscardRectangleStateCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& value);
inline void copyIndirectData(VkInputAttachmentAspectReference& value);
inline void copyIndirectData(VkRenderPassInputAttachmentAspectCreateInfo& value);
inline void copyIndirectData(VkPhysicalDeviceSurfaceInfo2KHR& value);
inline void copyIndirectData(VkSurfaceCapabilities2KHR& value);
inline void copyIndirectData(VkSurfaceFormat2KHR& value);
inline void copyIndirectData(VkDisplayProperties2KHR& value);
inline void copyIndirectData(VkDisplayPlaneProperties2KHR& value);
inline void copyIndirectData(VkDisplayModeProperties2KHR& value);
inline void copyIndirectData(VkDisplayPlaneInfo2KHR& value);
inline void copyIndirectData(VkDisplayPlaneCapabilities2KHR& value);
inline void copyIndirectData(VkSharedPresentSurfaceCapabilitiesKHR& value);
inline void copyIndirectData(VkPhysicalDevice16BitStorageFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceSubgroupProperties& value);
inline void copyIndirectData(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& value);
inline void copyIndirectData(VkBufferMemoryRequirementsInfo2& value);
inline void copyIndirectData(VkDeviceBufferMemoryRequirements& value);
inline void copyIndirectData(VkImageMemoryRequirementsInfo2& value);
inline void copyIndirectData(VkImageSparseMemoryRequirementsInfo2& value);
inline void copyIndirectData(VkDeviceImageMemoryRequirements& value);
inline void copyIndirectData(VkMemoryRequirements2& value);
inline void copyIndirectData(VkSparseImageMemoryRequirements2& value);
inline void copyIndirectData(VkPhysicalDevicePointClippingProperties& value);
inline void copyIndirectData(VkMemoryDedicatedRequirements& value);
inline void copyIndirectData(VkMemoryDedicatedAllocateInfo& value);
inline void copyIndirectData(VkImageViewUsageCreateInfo& value);
inline void copyIndirectData(VkPipelineTessellationDomainOriginStateCreateInfo& value);
inline void copyIndirectData(VkSamplerYcbcrConversionInfo& value);
inline void copyIndirectData(VkSamplerYcbcrConversionCreateInfo& value);
inline void copyIndirectData(VkBindImagePlaneMemoryInfo& value);
inline void copyIndirectData(VkImagePlaneMemoryRequirementsInfo& value);
inline void copyIndirectData(VkPhysicalDeviceSamplerYcbcrConversionFeatures& value);
inline void copyIndirectData(VkSamplerYcbcrConversionImageFormatProperties& value);
inline void copyIndirectData(VkTextureLODGatherFormatPropertiesAMD& value);
inline void copyIndirectData(VkConditionalRenderingBeginInfoEXT& value);
inline void copyIndirectData(VkProtectedSubmitInfo& value);
inline void copyIndirectData(VkPhysicalDeviceProtectedMemoryFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceProtectedMemoryProperties& value);
inline void copyIndirectData(VkDeviceQueueInfo2& value);
inline void copyIndirectData(VkPipelineCoverageToColorStateCreateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceSamplerFilterMinmaxProperties& value);
inline void copyIndirectData(VkSampleLocationEXT& value);
inline void copyIndirectData(VkSampleLocationsInfoEXT& value);
inline void copyIndirectData(VkAttachmentSampleLocationsEXT& value);
inline void copyIndirectData(VkSubpassSampleLocationsEXT& value);
inline void copyIndirectData(VkRenderPassSampleLocationsBeginInfoEXT& value);
inline void copyIndirectData(VkPipelineSampleLocationsStateCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceSampleLocationsPropertiesEXT& value);
inline void copyIndirectData(VkMultisamplePropertiesEXT& value);
inline void copyIndirectData(VkSamplerReductionModeCreateInfo& value);
inline void copyIndirectData(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceMultiDrawFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& value);
inline void copyIndirectData(VkPipelineColorBlendAdvancedStateCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceInlineUniformBlockFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceInlineUniformBlockProperties& value);
inline void copyIndirectData(VkWriteDescriptorSetInlineUniformBlock& value);
inline void copyIndirectData(VkDescriptorPoolInlineUniformBlockCreateInfo& value);
inline void copyIndirectData(VkPipelineCoverageModulationStateCreateInfoNV& value);
inline void copyIndirectData(VkImageFormatListCreateInfo& value);
inline void copyIndirectData(VkValidationCacheCreateInfoEXT& value);
inline void copyIndirectData(VkShaderModuleValidationCacheCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceMaintenance3Properties& value);
inline void copyIndirectData(VkPhysicalDeviceMaintenance4Features& value);
inline void copyIndirectData(VkPhysicalDeviceMaintenance4Properties& value);
inline void copyIndirectData(VkDescriptorSetLayoutSupport& value);
inline void copyIndirectData(VkPhysicalDeviceShaderDrawParametersFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceShaderFloat16Int8Features& value);
inline void copyIndirectData(VkPhysicalDeviceFloatControlsProperties& value);
inline void copyIndirectData(VkPhysicalDeviceHostQueryResetFeatures& value);
inline void copyIndirectData(VkShaderResourceUsageAMD& value);
inline void copyIndirectData(VkShaderStatisticsInfoAMD& value);
inline void copyIndirectData(VkDeviceQueueGlobalPriorityCreateInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& value);
inline void copyIndirectData(VkQueueFamilyGlobalPriorityPropertiesKHR& value);
inline void copyIndirectData(VkDebugUtilsObjectNameInfoEXT& value);
inline void copyIndirectData(VkDebugUtilsObjectTagInfoEXT& value);
inline void copyIndirectData(VkDebugUtilsLabelEXT& value);
inline void copyIndirectData(VkDebugUtilsMessengerCreateInfoEXT& value);
inline void copyIndirectData(VkDebugUtilsMessengerCallbackDataEXT& value);
inline void copyIndirectData(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& value);
inline void copyIndirectData(VkDeviceDeviceMemoryReportCreateInfoEXT& value);
inline void copyIndirectData(VkDeviceMemoryReportCallbackDataEXT& value);
inline void copyIndirectData(VkImportMemoryHostPointerInfoEXT& value);
inline void copyIndirectData(VkMemoryHostPointerPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceExternalMemoryHostPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceConservativeRasterizationPropertiesEXT& value);
inline void copyIndirectData(VkCalibratedTimestampInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceShaderCorePropertiesAMD& value);
inline void copyIndirectData(VkPhysicalDeviceShaderCoreProperties2AMD& value);
inline void copyIndirectData(VkPipelineRasterizationConservativeStateCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceDescriptorIndexingFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceDescriptorIndexingProperties& value);
inline void copyIndirectData(VkDescriptorSetLayoutBindingFlagsCreateInfo& value);
inline void copyIndirectData(VkDescriptorSetVariableDescriptorCountAllocateInfo& value);
inline void copyIndirectData(VkDescriptorSetVariableDescriptorCountLayoutSupport& value);
inline void copyIndirectData(VkAttachmentDescription2& value);
inline void copyIndirectData(VkAttachmentReference2& value);
inline void copyIndirectData(VkSubpassDescription2& value);
inline void copyIndirectData(VkSubpassDependency2& value);
inline void copyIndirectData(VkRenderPassCreateInfo2& value);
inline void copyIndirectData(VkSubpassBeginInfo& value);
inline void copyIndirectData(VkSubpassEndInfo& value);
inline void copyIndirectData(VkPhysicalDeviceTimelineSemaphoreFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceTimelineSemaphoreProperties& value);
inline void copyIndirectData(VkSemaphoreTypeCreateInfo& value);
inline void copyIndirectData(VkTimelineSemaphoreSubmitInfo& value);
inline void copyIndirectData(VkSemaphoreWaitInfo& value);
inline void copyIndirectData(VkSemaphoreSignalInfo& value);
inline void copyIndirectData(VkVertexInputBindingDivisorDescriptionEXT& value);
inline void copyIndirectData(VkPipelineVertexInputDivisorStateCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDevicePCIBusInfoPropertiesEXT& value);
inline void copyIndirectData(VkCommandBufferInheritanceConditionalRenderingInfoEXT& value);
inline void copyIndirectData(VkPhysicalDevice8BitStorageFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceConditionalRenderingFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceVulkanMemoryModelFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceShaderAtomicInt64Features& value);
inline void copyIndirectData(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value);
inline void copyIndirectData(VkQueueFamilyCheckpointPropertiesNV& value);
inline void copyIndirectData(VkCheckpointDataNV& value);
inline void copyIndirectData(VkPhysicalDeviceDepthStencilResolveProperties& value);
inline void copyIndirectData(VkSubpassDescriptionDepthStencilResolve& value);
inline void copyIndirectData(VkImageViewASTCDecodeModeEXT& value);
inline void copyIndirectData(VkPhysicalDeviceASTCDecodeFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceTransformFeedbackFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceTransformFeedbackPropertiesEXT& value);
inline void copyIndirectData(VkPipelineRasterizationStateStreamCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& value);
inline void copyIndirectData(VkPipelineRepresentativeFragmentTestStateCreateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceExclusiveScissorFeaturesNV& value);
inline void copyIndirectData(VkPipelineViewportExclusiveScissorStateCreateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceCornerSampledImageFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceShaderImageFootprintFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& value);
inline void copyIndirectData(VkShadingRatePaletteNV& value);
inline void copyIndirectData(VkPipelineViewportShadingRateImageStateCreateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceShadingRateImageFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceShadingRateImagePropertiesNV& value);
inline void copyIndirectData(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& value);
inline void copyIndirectData(VkCoarseSampleLocationNV& value);
inline void copyIndirectData(VkCoarseSampleOrderCustomNV& value);
inline void copyIndirectData(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceMeshShaderFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceMeshShaderPropertiesNV& value);
inline void copyIndirectData(VkDrawMeshTasksIndirectCommandNV& value);
inline void copyIndirectData(VkRayTracingShaderGroupCreateInfoNV& value);
inline void copyIndirectData(VkRayTracingShaderGroupCreateInfoKHR& value);
inline void copyIndirectData(VkRayTracingPipelineCreateInfoNV& value);
inline void copyIndirectData(VkRayTracingPipelineCreateInfoKHR& value);
inline void copyIndirectData(VkGeometryTrianglesNV& value);
inline void copyIndirectData(VkGeometryAABBNV& value);
inline void copyIndirectData(VkGeometryDataNV& value);
inline void copyIndirectData(VkGeometryNV& value);
inline void copyIndirectData(VkAccelerationStructureInfoNV& value);
inline void copyIndirectData(VkAccelerationStructureCreateInfoNV& value);
inline void copyIndirectData(VkBindAccelerationStructureMemoryInfoNV& value);
inline void copyIndirectData(VkWriteDescriptorSetAccelerationStructureKHR& value);
inline void copyIndirectData(VkWriteDescriptorSetAccelerationStructureNV& value);
inline void copyIndirectData(VkAccelerationStructureMemoryRequirementsInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceAccelerationStructureFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceRayTracingPipelineFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceRayQueryFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceAccelerationStructurePropertiesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceRayTracingPipelinePropertiesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceRayTracingPropertiesNV& value);
inline void copyIndirectData(VkStridedDeviceAddressRegionKHR& value);
inline void copyIndirectData(VkTraceRaysIndirectCommandKHR& value);
inline void copyIndirectData(VkTraceRaysIndirectCommand2KHR& value);
inline void copyIndirectData(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& value);
inline void copyIndirectData(VkDrmFormatModifierPropertiesListEXT& value);
inline void copyIndirectData(VkDrmFormatModifierPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceImageDrmFormatModifierInfoEXT& value);
inline void copyIndirectData(VkImageDrmFormatModifierListCreateInfoEXT& value);
inline void copyIndirectData(VkImageDrmFormatModifierExplicitCreateInfoEXT& value);
inline void copyIndirectData(VkImageDrmFormatModifierPropertiesEXT& value);
inline void copyIndirectData(VkImageStencilUsageCreateInfo& value);
inline void copyIndirectData(VkDeviceMemoryOverallocationCreateInfoAMD& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& value);
inline void copyIndirectData(VkRenderPassFragmentDensityMapCreateInfoEXT& value);
inline void copyIndirectData(VkSubpassFragmentDensityMapOffsetEndInfoQCOM& value);
inline void copyIndirectData(VkPhysicalDeviceScalarBlockLayoutFeatures& value);
inline void copyIndirectData(VkSurfaceProtectedCapabilitiesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceUniformBufferStandardLayoutFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceDepthClipEnableFeaturesEXT& value);
inline void copyIndirectData(VkPipelineRasterizationDepthClipStateCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceMemoryBudgetPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceMemoryPriorityFeaturesEXT& value);
inline void copyIndirectData(VkMemoryPriorityAllocateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceBufferDeviceAddressFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& value);
inline void copyIndirectData(VkBufferDeviceAddressInfo& value);
inline void copyIndirectData(VkBufferOpaqueCaptureAddressCreateInfo& value);
inline void copyIndirectData(VkBufferDeviceAddressCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceImageViewImageFormatInfoEXT& value);
inline void copyIndirectData(VkFilterCubicImageViewImageFormatPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceImagelessFramebufferFeatures& value);
inline void copyIndirectData(VkFramebufferAttachmentsCreateInfo& value);
inline void copyIndirectData(VkFramebufferAttachmentImageInfo& value);
inline void copyIndirectData(VkRenderPassAttachmentBeginInfo& value);
inline void copyIndirectData(VkPhysicalDeviceTextureCompressionASTCHDRFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceCooperativeMatrixFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceCooperativeMatrixPropertiesNV& value);
inline void copyIndirectData(VkCooperativeMatrixPropertiesNV& value);
inline void copyIndirectData(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& value);
inline void copyIndirectData(VkImageViewHandleInfoNVX& value);
inline void copyIndirectData(VkImageViewAddressPropertiesNVX& value);
inline void copyIndirectData(VkPipelineCreationFeedback& value);
inline void copyIndirectData(VkPipelineCreationFeedbackCreateInfo& value);
inline void copyIndirectData(VkPhysicalDevicePerformanceQueryFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDevicePerformanceQueryPropertiesKHR& value);
inline void copyIndirectData(VkPerformanceCounterKHR& value);
inline void copyIndirectData(VkPerformanceCounterDescriptionKHR& value);
inline void copyIndirectData(VkQueryPoolPerformanceCreateInfoKHR& value);
inline void copyIndirectData(VkAcquireProfilingLockInfoKHR& value);
inline void copyIndirectData(VkPerformanceQuerySubmitInfoKHR& value);
inline void copyIndirectData(VkHeadlessSurfaceCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceCoverageReductionModeFeaturesNV& value);
inline void copyIndirectData(VkPipelineCoverageReductionStateCreateInfoNV& value);
inline void copyIndirectData(VkFramebufferMixedSamplesCombinationNV& value);
inline void copyIndirectData(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& value);
inline void copyIndirectData(VkPerformanceValueINTEL& value);
inline void copyIndirectData(VkInitializePerformanceApiInfoINTEL& value);
inline void copyIndirectData(VkQueryPoolPerformanceQueryCreateInfoINTEL& value);
inline void copyIndirectData(VkPerformanceMarkerInfoINTEL& value);
inline void copyIndirectData(VkPerformanceStreamMarkerInfoINTEL& value);
inline void copyIndirectData(VkPerformanceOverrideInfoINTEL& value);
inline void copyIndirectData(VkPerformanceConfigurationAcquireInfoINTEL& value);
inline void copyIndirectData(VkPhysicalDeviceShaderClockFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceIndexTypeUint8FeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& value);
inline void copyIndirectData(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& value);
inline void copyIndirectData(VkAttachmentReferenceStencilLayout& value);
inline void copyIndirectData(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& value);
inline void copyIndirectData(VkAttachmentDescriptionStencilLayout& value);
inline void copyIndirectData(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value);
inline void copyIndirectData(VkPipelineInfoKHR& value);
inline void copyIndirectData(VkPipelineExecutablePropertiesKHR& value);
inline void copyIndirectData(VkPipelineExecutableInfoKHR& value);
inline void copyIndirectData(VkPipelineExecutableStatisticKHR& value);
inline void copyIndirectData(VkPipelineExecutableInternalRepresentationKHR& value);
inline void copyIndirectData(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceTexelBufferAlignmentProperties& value);
inline void copyIndirectData(VkPhysicalDeviceSubgroupSizeControlFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceSubgroupSizeControlProperties& value);
inline void copyIndirectData(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& value);
inline void copyIndirectData(VkSubpassShadingPipelineCreateInfoHUAWEI& value);
inline void copyIndirectData(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& value);
inline void copyIndirectData(VkMemoryOpaqueCaptureAddressAllocateInfo& value);
inline void copyIndirectData(VkDeviceMemoryOpaqueCaptureAddressInfo& value);
inline void copyIndirectData(VkPhysicalDeviceLineRasterizationFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceLineRasterizationPropertiesEXT& value);
inline void copyIndirectData(VkPipelineRasterizationLineStateCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDevicePipelineCreationCacheControlFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceVulkan11Features& value);
inline void copyIndirectData(VkPhysicalDeviceVulkan11Properties& value);
inline void copyIndirectData(VkPhysicalDeviceVulkan12Features& value);
inline void copyIndirectData(VkPhysicalDeviceVulkan12Properties& value);
inline void copyIndirectData(VkPhysicalDeviceVulkan13Features& value);
inline void copyIndirectData(VkPhysicalDeviceVulkan13Properties& value);
inline void copyIndirectData(VkPipelineCompilerControlCreateInfoAMD& value);
inline void copyIndirectData(VkPhysicalDeviceCoherentMemoryFeaturesAMD& value);
inline void copyIndirectData(VkPhysicalDeviceToolProperties& value);
inline void copyIndirectData(VkSamplerCustomBorderColorCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceCustomBorderColorPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceCustomBorderColorFeaturesEXT& value);
inline void copyIndirectData(VkSamplerBorderColorComponentMappingCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value);
inline void copyIndirectData(VkAccelerationStructureGeometryTrianglesDataKHR& value);
inline void copyIndirectData(VkAccelerationStructureGeometryAabbsDataKHR& value);
inline void copyIndirectData(VkAccelerationStructureGeometryInstancesDataKHR& value);
inline void copyIndirectData(VkAccelerationStructureGeometryKHR& value);
inline void copyIndirectData(VkAccelerationStructureBuildGeometryInfoKHR& value);
inline void copyIndirectData(VkAccelerationStructureBuildRangeInfoKHR& value);
inline void copyIndirectData(VkAccelerationStructureCreateInfoKHR& value);
inline void copyIndirectData(VkAabbPositionsKHR& value);
inline void copyIndirectData(VkTransformMatrixKHR& value);
inline void copyIndirectData(VkAccelerationStructureInstanceKHR& value);
inline void copyIndirectData(VkAccelerationStructureDeviceAddressInfoKHR& value);
inline void copyIndirectData(VkAccelerationStructureVersionInfoKHR& value);
inline void copyIndirectData(VkCopyAccelerationStructureInfoKHR& value);
inline void copyIndirectData(VkCopyAccelerationStructureToMemoryInfoKHR& value);
inline void copyIndirectData(VkCopyMemoryToAccelerationStructureInfoKHR& value);
inline void copyIndirectData(VkRayTracingPipelineInterfaceCreateInfoKHR& value);
inline void copyIndirectData(VkPipelineLibraryCreateInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& value);
inline void copyIndirectData(VkRenderPassTransformBeginInfoQCOM& value);
inline void copyIndirectData(VkCopyCommandTransformInfoQCOM& value);
inline void copyIndirectData(VkCommandBufferInheritanceRenderPassTransformInfoQCOM& value);
inline void copyIndirectData(VkPhysicalDeviceDiagnosticsConfigFeaturesNV& value);
inline void copyIndirectData(VkDeviceDiagnosticsConfigCreateInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceRobustness2FeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceRobustness2PropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceImageRobustnessFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDevice4444FormatsFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& value);
inline void copyIndirectData(VkBufferCopy2& value);
inline void copyIndirectData(VkImageCopy2& value);
inline void copyIndirectData(VkImageBlit2& value);
inline void copyIndirectData(VkBufferImageCopy2& value);
inline void copyIndirectData(VkImageResolve2& value);
inline void copyIndirectData(VkCopyBufferInfo2& value);
inline void copyIndirectData(VkCopyImageInfo2& value);
inline void copyIndirectData(VkBlitImageInfo2& value);
inline void copyIndirectData(VkCopyBufferToImageInfo2& value);
inline void copyIndirectData(VkCopyImageToBufferInfo2& value);
inline void copyIndirectData(VkResolveImageInfo2& value);
inline void copyIndirectData(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& value);
inline void copyIndirectData(VkFragmentShadingRateAttachmentInfoKHR& value);
inline void copyIndirectData(VkPipelineFragmentShadingRateStateCreateInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRatePropertiesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateKHR& value);
inline void copyIndirectData(VkPhysicalDeviceShaderTerminateInvocationFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& value);
inline void copyIndirectData(VkPipelineFragmentShadingRateEnumStateCreateInfoNV& value);
inline void copyIndirectData(VkAccelerationStructureBuildSizesInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& value);
inline void copyIndirectData(VkMutableDescriptorTypeListVALVE& value);
inline void copyIndirectData(VkMutableDescriptorTypeCreateInfoVALVE& value);
inline void copyIndirectData(VkPhysicalDeviceDepthClipControlFeaturesEXT& value);
inline void copyIndirectData(VkPipelineViewportDepthClipControlCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& value);
inline void copyIndirectData(VkVertexInputBindingDescription2EXT& value);
inline void copyIndirectData(VkVertexInputAttributeDescription2EXT& value);
inline void copyIndirectData(VkPhysicalDeviceColorWriteEnableFeaturesEXT& value);
inline void copyIndirectData(VkPipelineColorWriteCreateInfoEXT& value);
inline void copyIndirectData(VkMemoryBarrier2& value);
inline void copyIndirectData(VkImageMemoryBarrier2& value);
inline void copyIndirectData(VkBufferMemoryBarrier2& value);
inline void copyIndirectData(VkDependencyInfo& value);
inline void copyIndirectData(VkSemaphoreSubmitInfo& value);
inline void copyIndirectData(VkCommandBufferSubmitInfo& value);
inline void copyIndirectData(VkSubmitInfo2& value);
inline void copyIndirectData(VkQueueFamilyCheckpointProperties2NV& value);
inline void copyIndirectData(VkCheckpointData2NV& value);
inline void copyIndirectData(VkPhysicalDeviceSynchronization2Features& value);
inline void copyIndirectData(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& value);
inline void copyIndirectData(VkSubpassResolvePerformanceQueryEXT& value);
inline void copyIndirectData(VkMultisampledRenderToSingleSampledInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceInheritedViewportScissorFeaturesNV& value);
inline void copyIndirectData(VkCommandBufferInheritanceViewportScissorInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceProvokingVertexFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceProvokingVertexPropertiesEXT& value);
inline void copyIndirectData(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& value);
inline void copyIndirectData(VkCuModuleCreateInfoNVX& value);
inline void copyIndirectData(VkCuFunctionCreateInfoNVX& value);
inline void copyIndirectData(VkCuLaunchInfoNVX& value);
inline void copyIndirectData(VkPhysicalDeviceShaderIntegerDotProductFeatures& value);
inline void copyIndirectData(VkPhysicalDeviceShaderIntegerDotProductProperties& value);
inline void copyIndirectData(VkPhysicalDeviceDrmPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& value);
inline void copyIndirectData(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& value);
inline void copyIndirectData(VkAccelerationStructureGeometryMotionTrianglesDataNV& value);
inline void copyIndirectData(VkAccelerationStructureMotionInfoNV& value);
inline void copyIndirectData(VkSRTDataNV& value);
inline void copyIndirectData(VkAccelerationStructureSRTMotionInstanceNV& value);
inline void copyIndirectData(VkAccelerationStructureMatrixMotionInstanceNV& value);
inline void copyIndirectData(VkAccelerationStructureMotionInstanceNV& value);
inline void copyIndirectData(VkMemoryGetRemoteAddressInfoNV& value);
inline void copyIndirectData(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& value);
inline void copyIndirectData(VkFormatProperties3& value);
inline void copyIndirectData(VkDrmFormatModifierPropertiesList2EXT& value);
inline void copyIndirectData(VkDrmFormatModifierProperties2EXT& value);
inline void copyIndirectData(VkPipelineRenderingCreateInfo& value);
inline void copyIndirectData(VkRenderingInfo& value);
inline void copyIndirectData(VkRenderingAttachmentInfo& value);
inline void copyIndirectData(VkRenderingFragmentShadingRateAttachmentInfoKHR& value);
inline void copyIndirectData(VkRenderingFragmentDensityMapAttachmentInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceDynamicRenderingFeatures& value);
inline void copyIndirectData(VkCommandBufferInheritanceRenderingInfo& value);
inline void copyIndirectData(VkAttachmentSampleCountInfoAMD& value);
inline void copyIndirectData(VkMultiviewPerViewAttributesInfoNVX& value);
inline void copyIndirectData(VkPhysicalDeviceImageViewMinLodFeaturesEXT& value);
inline void copyIndirectData(VkImageViewMinLodCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceLinearColorAttachmentFeaturesNV& value);
inline void copyIndirectData(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& value);
inline void copyIndirectData(VkGraphicsPipelineLibraryCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& value);
inline void copyIndirectData(VkDescriptorSetBindingReferenceVALVE& value);
inline void copyIndirectData(VkDescriptorSetLayoutHostMappingInfoVALVE& value);
inline void copyIndirectData(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& value);
inline void copyIndirectData(VkPipelineShaderStageModuleIdentifierCreateInfoEXT& value);
inline void copyIndirectData(VkShaderModuleIdentifierEXT& value);
inline void copyIndirectData(VkImageCompressionControlEXT& value);
inline void copyIndirectData(VkPhysicalDeviceImageCompressionControlFeaturesEXT& value);
inline void copyIndirectData(VkImageCompressionPropertiesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& value);
inline void copyIndirectData(VkImageSubresource2EXT& value);
inline void copyIndirectData(VkSubresourceLayout2EXT& value);
inline void copyIndirectData(VkRenderPassCreationControlEXT& value);
inline void copyIndirectData(VkRenderPassCreationFeedbackInfoEXT& value);
inline void copyIndirectData(VkRenderPassCreationFeedbackCreateInfoEXT& value);
inline void copyIndirectData(VkRenderPassSubpassFeedbackInfoEXT& value);
inline void copyIndirectData(VkRenderPassSubpassFeedbackCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& value);
inline void copyIndirectData(VkPipelinePropertiesIdentifierEXT& value);
inline void copyIndirectData(VkPhysicalDevicePipelinePropertiesFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& value);
inline void copyIndirectData(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& value);
inline void copyIndirectData(VkPhysicalDevicePipelineRobustnessFeaturesEXT& value);
inline void copyIndirectData(VkPipelineRobustnessCreateInfoEXT& value);
inline void copyIndirectData(VkPhysicalDevicePipelineRobustnessPropertiesEXT& value);

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
inline void copyIndirectData(VkAndroidSurfaceCreateInfoKHR& value);
inline void copyIndirectData(VkNativeBufferUsage2ANDROID& value);
inline void copyIndirectData(VkNativeBufferANDROID& value);
inline void copyIndirectData(VkSwapchainImageCreateInfoANDROID& value);
inline void copyIndirectData(VkPhysicalDevicePresentationPropertiesANDROID& value);
inline void copyIndirectData(VkImportAndroidHardwareBufferInfoANDROID& value);
inline void copyIndirectData(VkAndroidHardwareBufferUsageANDROID& value);
inline void copyIndirectData(VkAndroidHardwareBufferPropertiesANDROID& value);
inline void copyIndirectData(VkMemoryGetAndroidHardwareBufferInfoANDROID& value);
inline void copyIndirectData(VkAndroidHardwareBufferFormatPropertiesANDROID& value);
inline void copyIndirectData(VkExternalFormatANDROID& value);

#endif // defined(VK_USE_PLATFORM_ANDROID_KHR)

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
inline void copyIndirectData(VkDirectFBSurfaceCreateInfoEXT& value);

#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#if defined(VK_USE_PLATFORM_FUCHSIA)
inline void copyIndirectData(VkImagePipeSurfaceCreateInfoFUCHSIA& value);
inline void copyIndirectData(VkImportMemoryZirconHandleInfoFUCHSIA& value);
inline void copyIndirectData(VkMemoryZirconHandlePropertiesFUCHSIA& value);
inline void copyIndirectData(VkMemoryGetZirconHandleInfoFUCHSIA& value);
inline void copyIndirectData(VkImportSemaphoreZirconHandleInfoFUCHSIA& value);
inline void copyIndirectData(VkSemaphoreGetZirconHandleInfoFUCHSIA& value);
inline void copyIndirectData(VkImportMemoryBufferCollectionFUCHSIA& value);
inline void copyIndirectData(VkBufferCollectionImageCreateInfoFUCHSIA& value);
inline void copyIndirectData(VkBufferCollectionBufferCreateInfoFUCHSIA& value);
inline void copyIndirectData(VkBufferCollectionCreateInfoFUCHSIA& value);
inline void copyIndirectData(VkBufferCollectionPropertiesFUCHSIA& value);
inline void copyIndirectData(VkBufferConstraintsInfoFUCHSIA& value);
inline void copyIndirectData(VkSysmemColorSpaceFUCHSIA& value);
inline void copyIndirectData(VkImageFormatConstraintsInfoFUCHSIA& value);
inline void copyIndirectData(VkImageConstraintsInfoFUCHSIA& value);
inline void copyIndirectData(VkBufferCollectionConstraintsInfoFUCHSIA& value);

#endif // defined(VK_USE_PLATFORM_FUCHSIA)

#if defined(VK_USE_PLATFORM_GGP)
inline void copyIndirectData(VkStreamDescriptorSurfaceCreateInfoGGP& value);
inline void copyIndirectData(VkPresentFrameTokenGGP& value);

#endif // defined(VK_USE_PLATFORM_GGP)

#if defined(VK_USE_PLATFORM_IOS_MVK)
inline void copyIndirectData(VkIOSSurfaceCreateInfoMVK& value);

#endif // defined(VK_USE_PLATFORM_IOS_MVK)

#if defined(VK_USE_PLATFORM_MACOS_MVK)
inline void copyIndirectData(VkMacOSSurfaceCreateInfoMVK& value);

#endif // defined(VK_USE_PLATFORM_MACOS_MVK)

#if defined(VK_USE_PLATFORM_METAL_EXT)
inline void copyIndirectData(VkMetalSurfaceCreateInfoEXT& value);
inline void copyIndirectData(VkExportMetalObjectCreateInfoEXT& value);
inline void copyIndirectData(VkExportMetalObjectsInfoEXT& value);
inline void copyIndirectData(VkExportMetalDeviceInfoEXT& value);
inline void copyIndirectData(VkExportMetalCommandQueueInfoEXT& value);
inline void copyIndirectData(VkExportMetalBufferInfoEXT& value);
inline void copyIndirectData(VkImportMetalBufferInfoEXT& value);
inline void copyIndirectData(VkExportMetalTextureInfoEXT& value);
inline void copyIndirectData(VkImportMetalTextureInfoEXT& value);
inline void copyIndirectData(VkExportMetalIOSurfaceInfoEXT& value);
inline void copyIndirectData(VkImportMetalIOSurfaceInfoEXT& value);
inline void copyIndirectData(VkExportMetalSharedEventInfoEXT& value);
inline void copyIndirectData(VkImportMetalSharedEventInfoEXT& value);

#endif // defined(VK_USE_PLATFORM_METAL_EXT)

#if defined(VK_ENABLE_BETA_EXTENSIONS)
inline void copyIndirectData(VkPhysicalDevicePortabilitySubsetFeaturesKHR& value);
inline void copyIndirectData(VkPhysicalDevicePortabilitySubsetPropertiesKHR& value);
inline void copyIndirectData(VkQueueFamilyVideoPropertiesKHR& value);
inline void copyIndirectData(VkQueueFamilyQueryResultStatusPropertiesKHR& value);
inline void copyIndirectData(VkVideoProfileListInfoKHR& value);
inline void copyIndirectData(VkPhysicalDeviceVideoFormatInfoKHR& value);
inline void copyIndirectData(VkVideoFormatPropertiesKHR& value);
inline void copyIndirectData(VkVideoProfileInfoKHR& value);
inline void copyIndirectData(VkVideoCapabilitiesKHR& value);
inline void copyIndirectData(VkVideoSessionMemoryRequirementsKHR& value);
inline void copyIndirectData(VkBindVideoSessionMemoryInfoKHR& value);
inline void copyIndirectData(VkVideoPictureResourceInfoKHR& value);
inline void copyIndirectData(VkVideoReferenceSlotInfoKHR& value);
inline void copyIndirectData(VkVideoDecodeCapabilitiesKHR& value);
inline void copyIndirectData(VkVideoDecodeUsageInfoKHR& value);
inline void copyIndirectData(VkVideoDecodeInfoKHR& value);
inline void copyIndirectData(VkVideoDecodeH264ProfileInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH264CapabilitiesEXT& value);
inline void copyIndirectData(VkVideoDecodeH264SessionParametersAddInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH264SessionParametersCreateInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH264PictureInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH264DpbSlotInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH264MvcInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH265ProfileInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH265CapabilitiesEXT& value);
inline void copyIndirectData(VkVideoDecodeH265SessionParametersAddInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH265SessionParametersCreateInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH265PictureInfoEXT& value);
inline void copyIndirectData(VkVideoDecodeH265DpbSlotInfoEXT& value);
inline void copyIndirectData(VkVideoSessionCreateInfoKHR& value);
inline void copyIndirectData(VkVideoSessionParametersCreateInfoKHR& value);
inline void copyIndirectData(VkVideoSessionParametersUpdateInfoKHR& value);
inline void copyIndirectData(VkVideoBeginCodingInfoKHR& value);
inline void copyIndirectData(VkVideoEndCodingInfoKHR& value);
inline void copyIndirectData(VkVideoCodingControlInfoKHR& value);
inline void copyIndirectData(VkVideoEncodeUsageInfoKHR& value);
inline void copyIndirectData(VkVideoEncodeInfoKHR& value);
inline void copyIndirectData(VkVideoEncodeRateControlInfoKHR& value);
inline void copyIndirectData(VkVideoEncodeRateControlLayerInfoKHR& value);
inline void copyIndirectData(VkVideoEncodeCapabilitiesKHR& value);
inline void copyIndirectData(VkVideoEncodeH264CapabilitiesEXT& value);
inline void copyIndirectData(VkVideoEncodeH264SessionParametersAddInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264SessionParametersCreateInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264DpbSlotInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264VclFrameInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264ReferenceListsInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264EmitPictureParametersInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264ProfileInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264NaluSliceInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264RateControlInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH264QpEXT& value);
inline void copyIndirectData(VkVideoEncodeH264FrameSizeEXT& value);
inline void copyIndirectData(VkVideoEncodeH264RateControlLayerInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265CapabilitiesEXT& value);
inline void copyIndirectData(VkVideoEncodeH265SessionParametersAddInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265SessionParametersCreateInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265VclFrameInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265EmitPictureParametersInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265NaluSliceSegmentInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265RateControlInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265QpEXT& value);
inline void copyIndirectData(VkVideoEncodeH265FrameSizeEXT& value);
inline void copyIndirectData(VkVideoEncodeH265RateControlLayerInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265ProfileInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265DpbSlotInfoEXT& value);
inline void copyIndirectData(VkVideoEncodeH265ReferenceListsInfoEXT& value);

#endif // defined(VK_ENABLE_BETA_EXTENSIONS)

#if defined(VK_USE_PLATFORM_SCREEN_QNX)
inline void copyIndirectData(VkScreenSurfaceCreateInfoQNX& value);

#endif // defined(VK_USE_PLATFORM_SCREEN_QNX)

#if defined(VK_USE_PLATFORM_VI_NN)
inline void copyIndirectData(VkViSurfaceCreateInfoNN& value);

#endif // defined(VK_USE_PLATFORM_VI_NN)

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
inline void copyIndirectData(VkWaylandSurfaceCreateInfoKHR& value);

#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR)

#if defined(VK_USE_PLATFORM_WIN32_KHR)
inline void copyIndirectData(VkWin32SurfaceCreateInfoKHR& value);
inline void copyIndirectData(VkImportMemoryWin32HandleInfoNV& value);
inline void copyIndirectData(VkExportMemoryWin32HandleInfoNV& value);
inline void copyIndirectData(VkWin32KeyedMutexAcquireReleaseInfoNV& value);
inline void copyIndirectData(VkImportMemoryWin32HandleInfoKHR& value);
inline void copyIndirectData(VkExportMemoryWin32HandleInfoKHR& value);
inline void copyIndirectData(VkMemoryWin32HandlePropertiesKHR& value);
inline void copyIndirectData(VkMemoryGetWin32HandleInfoKHR& value);
inline void copyIndirectData(VkWin32KeyedMutexAcquireReleaseInfoKHR& value);
inline void copyIndirectData(VkImportSemaphoreWin32HandleInfoKHR& value);
inline void copyIndirectData(VkExportSemaphoreWin32HandleInfoKHR& value);
inline void copyIndirectData(VkD3D12FenceSubmitInfoKHR& value);
inline void copyIndirectData(VkSemaphoreGetWin32HandleInfoKHR& value);
inline void copyIndirectData(VkImportFenceWin32HandleInfoKHR& value);
inline void copyIndirectData(VkExportFenceWin32HandleInfoKHR& value);
inline void copyIndirectData(VkFenceGetWin32HandleInfoKHR& value);
inline void copyIndirectData(VkSurfaceFullScreenExclusiveInfoEXT& value);
inline void copyIndirectData(VkSurfaceCapabilitiesFullScreenExclusiveEXT& value);

#endif // defined(VK_USE_PLATFORM_WIN32_KHR)

#if defined(VK_USE_PLATFORM_XCB_KHR)
inline void copyIndirectData(VkXcbSurfaceCreateInfoKHR& value);

#endif // defined(VK_USE_PLATFORM_XCB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_KHR)
inline void copyIndirectData(VkXlibSurfaceCreateInfoKHR& value);
#endif // defined(VK_USE_PLATFORM_XLIB_KHR)

inline void copyIndirectData([[maybe_unused]] VkBaseOutStructure& value)
{
    if (value.pNext != nullptr)
    {
        using base_type_t = std::decay_t<struct VkBaseOutStructure>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pNext, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pNext = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkBaseInStructure& value)
{
    if (value.pNext != nullptr)
    {
        using base_type_t = std::decay_t<const struct VkBaseInStructure>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pNext, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pNext = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkOffset2D& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkOffset3D& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkExtent2D& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkExtent3D& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkViewport& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkRect2D& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkClearRect& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkComponentMapping& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkExtensionProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkLayerProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkApplicationInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pApplicationName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pApplicationName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pApplicationName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pApplicationName = copy;
    }

    if (value.pEngineName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pEngineName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pEngineName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pEngineName = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAllocationCallbacks& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDeviceQueueCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pQueuePriorities != nullptr)
    {
        using base_type_t = std::decay_t<const float>;
        const std::size_t numElements = value.queueCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pQueuePriorities, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pQueuePriorities = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDeviceCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pQueueCreateInfos != nullptr)
    {
        using base_type_t = std::decay_t<const VkDeviceQueueCreateInfo>;
        const std::size_t numElements = value.queueCreateInfoCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pQueueCreateInfos, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pQueueCreateInfos = copy;
    }

    if (value.ppEnabledLayerNames != nullptr)
    {
        using base_type_t = std::decay_t<const char* const>;
        const std::size_t numElements = value.enabledLayerCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.ppEnabledLayerNames, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.ppEnabledLayerNames = copy;
    }

    if (value.ppEnabledExtensionNames != nullptr)
    {
        using base_type_t = std::decay_t<const char* const>;
        const std::size_t numElements = value.enabledExtensionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.ppEnabledExtensionNames, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.ppEnabledExtensionNames = copy;
    }

    if (value.pEnabledFeatures != nullptr)
    {
        using base_type_t = std::decay_t<const VkPhysicalDeviceFeatures>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pEnabledFeatures, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pEnabledFeatures = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkInstanceCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pApplicationInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkApplicationInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pApplicationInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pApplicationInfo = copy;
    }

    if (value.ppEnabledLayerNames != nullptr)
    {
        using base_type_t = std::decay_t<const char* const>;
        const std::size_t numElements = value.enabledLayerCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.ppEnabledLayerNames, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.ppEnabledLayerNames = copy;
    }

    if (value.ppEnabledExtensionNames != nullptr)
    {
        using base_type_t = std::decay_t<const char* const>;
        const std::size_t numElements = value.enabledExtensionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.ppEnabledExtensionNames, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.ppEnabledExtensionNames = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkQueueFamilyProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMemoryAllocateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryRequirements& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSparseImageFormatProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryRequirements& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMemoryType& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMemoryHeap& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMappedMemoryRange& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFormatProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkImageFormatProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorBufferInfo& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorImageInfo& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSet& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pImageInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorImageInfo>;
        const std::size_t numElements = value.descriptorCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pImageInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pImageInfo = copy;
    }

    if (value.pBufferInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorBufferInfo>;
        const std::size_t numElements = value.descriptorCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBufferInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBufferInfo = copy;
    }

    if (value.pTexelBufferView != nullptr)
    {
        using base_type_t = std::decay_t<const VkBufferView>;
        const std::size_t numElements = value.descriptorCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pTexelBufferView, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pTexelBufferView = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkCopyDescriptorSet& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pQueueFamilyIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.queueFamilyIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pQueueFamilyIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkBufferViewCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageSubresource& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkImageSubresourceLayers& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkImageSubresourceRange& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMemoryBarrier& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferMemoryBarrier& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageMemoryBarrier& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pQueueFamilyIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.queueFamilyIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pQueueFamilyIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSubresourceLayout& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkImageViewCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferCopy& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSparseMemoryBind& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryBind& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSparseBufferMemoryBindInfo& value)
{
    if (value.pBinds != nullptr)
    {
        using base_type_t = std::decay_t<const VkSparseMemoryBind>;
        const std::size_t numElements = value.bindCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBinds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBinds = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSparseImageOpaqueMemoryBindInfo& value)
{
    if (value.pBinds != nullptr)
    {
        using base_type_t = std::decay_t<const VkSparseMemoryBind>;
        const std::size_t numElements = value.bindCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBinds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBinds = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryBindInfo& value)
{
    if (value.pBinds != nullptr)
    {
        using base_type_t = std::decay_t<const VkSparseImageMemoryBind>;
        const std::size_t numElements = value.bindCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBinds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBinds = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkBindSparseInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pWaitSemaphores != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphore>;
        const std::size_t numElements = value.waitSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitSemaphores, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitSemaphores = copy;
    }

    if (value.pBufferBinds != nullptr)
    {
        using base_type_t = std::decay_t<const VkSparseBufferMemoryBindInfo>;
        const std::size_t numElements = value.bufferBindCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBufferBinds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBufferBinds = copy;
    }

    if (value.pImageOpaqueBinds != nullptr)
    {
        using base_type_t = std::decay_t<const VkSparseImageOpaqueMemoryBindInfo>;
        const std::size_t numElements = value.imageOpaqueBindCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pImageOpaqueBinds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pImageOpaqueBinds = copy;
    }

    if (value.pImageBinds != nullptr)
    {
        using base_type_t = std::decay_t<const VkSparseImageMemoryBindInfo>;
        const std::size_t numElements = value.imageBindCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pImageBinds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pImageBinds = copy;
    }

    if (value.pSignalSemaphores != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphore>;
        const std::size_t numElements = value.signalSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSignalSemaphores, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSignalSemaphores = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageCopy& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkImageBlit& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkBufferImageCopy& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkImageResolve& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkShaderModuleCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pCode != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.codeSize / 4;
                
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCode, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCode = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutBinding& value)
{
    if (value.pImmutableSamplers != nullptr)
    {
        using base_type_t = std::decay_t<const VkSampler>;
        const std::size_t numElements = value.descriptorCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pImmutableSamplers, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pImmutableSamplers = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pBindings != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorSetLayoutBinding>;
        const std::size_t numElements = value.bindingCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBindings, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBindings = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDescriptorPoolSize& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorPoolCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pPoolSizes != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorPoolSize>;
        const std::size_t numElements = value.poolSizeCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPoolSizes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPoolSizes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetAllocateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSetLayouts != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorSetLayout>;
        const std::size_t numElements = value.descriptorSetCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSetLayouts, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSetLayouts = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSpecializationMapEntry& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSpecializationInfo& value)
{
    if (value.pMapEntries != nullptr)
    {
        using base_type_t = std::decay_t<const VkSpecializationMapEntry>;
        const std::size_t numElements = value.mapEntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMapEntries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMapEntries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineShaderStageCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pName = copy;
    }

    if (value.pSpecializationInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkSpecializationInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSpecializationInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSpecializationInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkComputePipelineCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVertexInputBindingDescription& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkVertexInputAttributeDescription& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineVertexInputStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pVertexBindingDescriptions != nullptr)
    {
        using base_type_t = std::decay_t<const VkVertexInputBindingDescription>;
        const std::size_t numElements = value.vertexBindingDescriptionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVertexBindingDescriptions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVertexBindingDescriptions = copy;
    }

    if (value.pVertexAttributeDescriptions != nullptr)
    {
        using base_type_t = std::decay_t<const VkVertexInputAttributeDescription>;
        const std::size_t numElements = value.vertexAttributeDescriptionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVertexAttributeDescriptions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVertexAttributeDescriptions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineInputAssemblyStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineTessellationStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineViewportStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pViewports != nullptr)
    {
        using base_type_t = std::decay_t<const VkViewport>;
        const std::size_t numElements = value.viewportCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewports, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewports = copy;
    }

    if (value.pScissors != nullptr)
    {
        using base_type_t = std::decay_t<const VkRect2D>;
        const std::size_t numElements = value.scissorCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pScissors, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pScissors = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineMultisampleStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSampleMask != nullptr)
    {
        using base_type_t = std::decay_t<const VkSampleMask>;
        const std::size_t numElements = (value.rasterizationSamples + 31) / 32;
                
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSampleMask, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSampleMask = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineColorBlendAttachmentState& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineColorBlendStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineColorBlendAttachmentState>;
        const std::size_t numElements = value.attachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttachments = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineDynamicStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDynamicStates != nullptr)
    {
        using base_type_t = std::decay_t<const VkDynamicState>;
        const std::size_t numElements = value.dynamicStateCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDynamicStates, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDynamicStates = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkStencilOpState& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineDepthStencilStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkGraphicsPipelineCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStages != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineShaderStageCreateInfo>;
        const std::size_t numElements = value.stageCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStages = copy;
    }

    if (value.pVertexInputState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineVertexInputStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVertexInputState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVertexInputState = copy;
    }

    if (value.pInputAssemblyState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineInputAssemblyStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pInputAssemblyState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pInputAssemblyState = copy;
    }

    if (value.pTessellationState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineTessellationStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pTessellationState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pTessellationState = copy;
    }

    if (value.pViewportState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineViewportStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewportState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewportState = copy;
    }

    if (value.pRasterizationState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineRasterizationStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRasterizationState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRasterizationState = copy;
    }

    if (value.pMultisampleState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineMultisampleStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMultisampleState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMultisampleState = copy;
    }

    if (value.pDepthStencilState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineDepthStencilStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDepthStencilState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDepthStencilState = copy;
    }

    if (value.pColorBlendState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineColorBlendStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorBlendState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorBlendState = copy;
    }

    if (value.pDynamicState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineDynamicStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDynamicState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDynamicState = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineCacheCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineCacheHeaderVersionOne& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPushConstantRange& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineLayoutCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSetLayouts != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorSetLayout>;
        const std::size_t numElements = value.setLayoutCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSetLayouts, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSetLayouts = copy;
    }

    if (value.pPushConstantRanges != nullptr)
    {
        using base_type_t = std::decay_t<const VkPushConstantRange>;
        const std::size_t numElements = value.pushConstantRangeCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPushConstantRanges, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPushConstantRanges = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSamplerCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandPoolCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferAllocateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferBeginInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pInheritanceInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkCommandBufferInheritanceInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pInheritanceInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pInheritanceInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkRenderPassBeginInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pClearValues != nullptr)
    {
        using base_type_t = std::decay_t<const VkClearValue>;
        const std::size_t numElements = value.clearValueCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pClearValues, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pClearValues = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkClearDepthStencilValue& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkClearAttachment& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAttachmentDescription& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAttachmentReference& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSubpassDescription& value)
{
    if (value.pInputAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference>;
        const std::size_t numElements = value.inputAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pInputAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pInputAttachments = copy;
    }

    if (value.pColorAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorAttachments = copy;
    }

    if (value.pResolveAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pResolveAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pResolveAttachments = copy;
    }

    if (value.pDepthStencilAttachment != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDepthStencilAttachment, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDepthStencilAttachment = copy;
    }

    if (value.pPreserveAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.preserveAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPreserveAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPreserveAttachments = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSubpassDependency& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentDescription>;
        const std::size_t numElements = value.attachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttachments = copy;
    }

    if (value.pSubpasses != nullptr)
    {
        using base_type_t = std::decay_t<const VkSubpassDescription>;
        const std::size_t numElements = value.subpassCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSubpasses, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSubpasses = copy;
    }

    if (value.pDependencies != nullptr)
    {
        using base_type_t = std::decay_t<const VkSubpassDependency>;
        const std::size_t numElements = value.dependencyCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDependencies, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDependencies = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkEventCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFenceCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFeatures& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSparseProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLimits& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueryPoolCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFramebufferCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageView>;
        const std::size_t numElements = value.attachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttachments = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDrawIndirectCommand& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDrawIndexedIndirectCommand& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDispatchIndirectCommand& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMultiDrawInfoEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMultiDrawIndexedInfoEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSubmitInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pWaitSemaphores != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphore>;
        const std::size_t numElements = value.waitSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitSemaphores, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitSemaphores = copy;
    }

    if (value.pWaitDstStageMask != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineStageFlags>;
        const std::size_t numElements = value.waitSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitDstStageMask, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitDstStageMask = copy;
    }

    if (value.pCommandBuffers != nullptr)
    {
        using base_type_t = std::decay_t<const VkCommandBuffer>;
        const std::size_t numElements = value.commandBufferCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCommandBuffers, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCommandBuffers = copy;
    }

    if (value.pSignalSemaphores != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphore>;
        const std::size_t numElements = value.signalSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSignalSemaphores, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSignalSemaphores = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDisplayPropertiesKHR& value)
{
    if (value.displayName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.displayName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.displayName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.displayName = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDisplayPlanePropertiesKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDisplayModeParametersKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDisplayModePropertiesKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDisplayModeCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneCapabilitiesKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDisplaySurfaceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayPresentInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilitiesKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSurfaceFormatKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSwapchainCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pQueueFamilyIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.queueFamilyIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pQueueFamilyIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPresentInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pWaitSemaphores != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphore>;
        const std::size_t numElements = value.waitSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitSemaphores, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitSemaphores = copy;
    }

    if (value.pSwapchains != nullptr)
    {
        using base_type_t = std::decay_t<const VkSwapchainKHR>;
        const std::size_t numElements = value.swapchainCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSwapchains, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSwapchains = copy;
    }

    if (value.pImageIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.swapchainCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pImageIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pImageIndices = copy;
    }

    if (value.pResults != nullptr)
    {
        using base_type_t = std::decay_t<VkResult>;
        const std::size_t numElements = value.swapchainCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pResults, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pResults = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDebugReportCallbackCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkValidationFlagsEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDisabledValidationChecks != nullptr)
    {
        using base_type_t = std::decay_t<const VkValidationCheckEXT>;
        const std::size_t numElements = value.disabledValidationCheckCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDisabledValidationChecks, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDisabledValidationChecks = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkValidationFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pEnabledValidationFeatures != nullptr)
    {
        using base_type_t = std::decay_t<const VkValidationFeatureEnableEXT>;
        const std::size_t numElements = value.enabledValidationFeatureCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pEnabledValidationFeatures, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pEnabledValidationFeatures = copy;
    }

    if (value.pDisabledValidationFeatures != nullptr)
    {
        using base_type_t = std::decay_t<const VkValidationFeatureDisableEXT>;
        const std::size_t numElements = value.disabledValidationFeatureCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDisabledValidationFeatures, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDisabledValidationFeatures = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationStateRasterizationOrderAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDebugMarkerObjectNameInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pObjectName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pObjectName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pObjectName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pObjectName = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDebugMarkerObjectTagInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDebugMarkerMarkerInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pMarkerName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pMarkerName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMarkerName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMarkerName = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDedicatedAllocationImageCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDedicatedAllocationBufferCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDedicatedAllocationMemoryAllocateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalImageFormatPropertiesNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkExternalMemoryImageCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMemoryAllocateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDevicePrivateDataCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPrivateDataSlotCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePrivateDataFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiDrawPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkGraphicsShaderGroupCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStages != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineShaderStageCreateInfo>;
        const std::size_t numElements = value.stageCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStages = copy;
    }

    if (value.pVertexInputState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineVertexInputStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVertexInputState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVertexInputState = copy;
    }

    if (value.pTessellationState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineTessellationStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pTessellationState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pTessellationState = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkGraphicsPipelineShaderGroupsCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pGroups != nullptr)
    {
        using base_type_t = std::decay_t<const VkGraphicsShaderGroupCreateInfoNV>;
        const std::size_t numElements = value.groupCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pGroups, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pGroups = copy;
    }

    if (value.pPipelines != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipeline>;
        const std::size_t numElements = value.pipelineCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPipelines, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPipelines = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkBindShaderGroupIndirectCommandNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkBindIndexBufferIndirectCommandNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkBindVertexBufferIndirectCommandNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSetStateFlagsIndirectCommandNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkIndirectCommandsStreamNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkIndirectCommandsLayoutTokenNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pIndexTypes != nullptr)
    {
        using base_type_t = std::decay_t<const VkIndexType>;
        const std::size_t numElements = value.indexTypeCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pIndexTypes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pIndexTypes = copy;
    }

    if (value.pIndexTypeValues != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.indexTypeCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pIndexTypeValues, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pIndexTypeValues = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkIndirectCommandsLayoutCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pTokens != nullptr)
    {
        using base_type_t = std::decay_t<const VkIndirectCommandsLayoutTokenNV>;
        const std::size_t numElements = value.tokenCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pTokens, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pTokens = copy;
    }

    if (value.pStreamStrides != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.streamCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStreamStrides, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStreamStrides = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkGeneratedCommandsInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStreams != nullptr)
    {
        using base_type_t = std::decay_t<const VkIndirectCommandsStreamNV>;
        const std::size_t numElements = value.streamCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStreams, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStreams = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkGeneratedCommandsMemoryRequirementsInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFeatures2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProperties2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFormatProperties2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageFormatProperties2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageFormatInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueueFamilyProperties2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryProperties2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSparseImageFormatProperties2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSparseImageFormatInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePushDescriptorPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkConformanceVersion& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDriverProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPresentRegionsKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkPresentRegionKHR>;
        const std::size_t numElements = value.swapchainCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPresentRegionKHR& value)
{
    if (value.pRectangles != nullptr)
    {
        using base_type_t = std::decay_t<const VkRectLayerKHR>;
        const std::size_t numElements = value.rectangleCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRectangles, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRectangles = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkRectLayerKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVariablePointersFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalMemoryProperties& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalImageFormatInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalImageFormatProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalBufferInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalBufferProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceIDProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalMemoryImageCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalMemoryBufferCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMemoryAllocateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMemoryFdInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryFdPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryGetFdInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalSemaphoreInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalSemaphoreProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportSemaphoreCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportSemaphoreFdInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreGetFdInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalFenceInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalFenceProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportFenceCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportFenceFdInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFenceGetFdInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiviewFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiviewProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassMultiviewCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pViewMasks != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.subpassCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewMasks, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewMasks = copy;
    }

    if (value.pViewOffsets != nullptr)
    {
        using base_type_t = std::decay_t<const int32_t>;
        const std::size_t numElements = value.dependencyCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewOffsets, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewOffsets = copy;
    }

    if (value.pCorrelationMasks != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.correlationMaskCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCorrelationMasks, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCorrelationMasks = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilities2EXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayPowerInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceEventInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayEventInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSwapchainCounterCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGroupProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryAllocateFlagsInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBindBufferMemoryInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBindBufferMemoryDeviceGroupInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDeviceIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.deviceIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDeviceIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDeviceIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkBindImageMemoryInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBindImageMemoryDeviceGroupInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDeviceIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.deviceIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDeviceIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDeviceIndices = copy;
    }

    if (value.pSplitInstanceBindRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkRect2D>;
        const std::size_t numElements = value.splitInstanceBindRegionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSplitInstanceBindRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSplitInstanceBindRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupRenderPassBeginInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDeviceRenderAreas != nullptr)
    {
        using base_type_t = std::decay_t<const VkRect2D>;
        const std::size_t numElements = value.deviceRenderAreaCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDeviceRenderAreas, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDeviceRenderAreas = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupCommandBufferBeginInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupSubmitInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pWaitSemaphoreDeviceIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.waitSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitSemaphoreDeviceIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitSemaphoreDeviceIndices = copy;
    }

    if (value.pCommandBufferDeviceMasks != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.commandBufferCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCommandBufferDeviceMasks, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCommandBufferDeviceMasks = copy;
    }

    if (value.pSignalSemaphoreDeviceIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.signalSemaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSignalSemaphoreDeviceIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSignalSemaphoreDeviceIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupBindSparseInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupPresentCapabilitiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageSwapchainCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBindImageMemorySwapchainInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAcquireNextImageInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupPresentInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDeviceMasks != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.swapchainCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDeviceMasks, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDeviceMasks = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupDeviceCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pPhysicalDevices != nullptr)
    {
        using base_type_t = std::decay_t<const VkPhysicalDevice>;
        const std::size_t numElements = value.physicalDeviceCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPhysicalDevices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPhysicalDevices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDeviceGroupSwapchainCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorUpdateTemplateEntry& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorUpdateTemplateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDescriptorUpdateEntries != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorUpdateTemplateEntry>;
        const std::size_t numElements = value.descriptorUpdateEntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDescriptorUpdateEntries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDescriptorUpdateEntries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkXYColorEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePresentIdFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPresentIdKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pPresentIds != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.swapchainCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPresentIds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPresentIds = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePresentWaitFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkHdrMetadataEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayNativeHdrSurfaceCapabilitiesAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSwapchainDisplayNativeHdrCreateInfoAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRefreshCycleDurationGOOGLE& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPastPresentationTimingGOOGLE& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPresentTimesInfoGOOGLE& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pTimes != nullptr)
    {
        using base_type_t = std::decay_t<const VkPresentTimeGOOGLE>;
        const std::size_t numElements = value.swapchainCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pTimes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pTimes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPresentTimeGOOGLE& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkViewportWScalingNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineViewportWScalingStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pViewportWScalings != nullptr)
    {
        using base_type_t = std::decay_t<const VkViewportWScalingNV>;
        const std::size_t numElements = value.viewportCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewportWScalings, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewportWScalings = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkViewportSwizzleNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineViewportSwizzleStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pViewportSwizzles != nullptr)
    {
        using base_type_t = std::decay_t<const VkViewportSwizzleNV>;
        const std::size_t numElements = value.viewportCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewportSwizzles, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewportSwizzles = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDiscardRectanglePropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineDiscardRectangleStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDiscardRectangles != nullptr)
    {
        using base_type_t = std::decay_t<const VkRect2D>;
        const std::size_t numElements = value.discardRectangleCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDiscardRectangles, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDiscardRectangles = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkInputAttachmentAspectReference& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassInputAttachmentAspectCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAspectReferences != nullptr)
    {
        using base_type_t = std::decay_t<const VkInputAttachmentAspectReference>;
        const std::size_t numElements = value.aspectReferenceCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAspectReferences, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAspectReferences = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSurfaceInfo2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilities2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSurfaceFormat2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayProperties2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneProperties2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayModeProperties2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneInfo2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneCapabilities2KHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSharedPresentSurfaceCapabilitiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevice16BitStorageFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubgroupProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferMemoryRequirementsInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceBufferMemoryRequirements& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pCreateInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkBufferCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCreateInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCreateInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageMemoryRequirementsInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageSparseMemoryRequirementsInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceImageMemoryRequirements& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pCreateInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCreateInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCreateInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkMemoryRequirements2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryRequirements2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePointClippingProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryDedicatedRequirements& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryDedicatedAllocateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageViewUsageCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineTessellationDomainOriginStateCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSamplerYcbcrConversionInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSamplerYcbcrConversionCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBindImagePlaneMemoryInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImagePlaneMemoryRequirementsInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSamplerYcbcrConversionFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSamplerYcbcrConversionImageFormatProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkTextureLODGatherFormatPropertiesAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkConditionalRenderingBeginInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkProtectedSubmitInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProtectedMemoryFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProtectedMemoryProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceQueueInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineCoverageToColorStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSamplerFilterMinmaxProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSampleLocationEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSampleLocationsInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSampleLocations != nullptr)
    {
        using base_type_t = std::decay_t<const VkSampleLocationEXT>;
        const std::size_t numElements = value.sampleLocationsCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSampleLocations, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSampleLocations = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAttachmentSampleLocationsEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkSubpassSampleLocationsEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassSampleLocationsBeginInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttachmentInitialSampleLocations != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentSampleLocationsEXT>;
        const std::size_t numElements = value.attachmentInitialSampleLocationsCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttachmentInitialSampleLocations, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttachmentInitialSampleLocations = copy;
    }

    if (value.pPostSubpassSampleLocations != nullptr)
    {
        using base_type_t = std::decay_t<const VkSubpassSampleLocationsEXT>;
        const std::size_t numElements = value.postSubpassSampleLocationsCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPostSubpassSampleLocations, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPostSubpassSampleLocations = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineSampleLocationsStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSampleLocationsPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMultisamplePropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSamplerReductionModeCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiDrawFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineColorBlendAdvancedStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInlineUniformBlockFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInlineUniformBlockProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSetInlineUniformBlock& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorPoolInlineUniformBlockCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineCoverageModulationStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pCoverageModulationTable != nullptr)
    {
        using base_type_t = std::decay_t<const float>;
        const std::size_t numElements = value.coverageModulationTableCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCoverageModulationTable, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCoverageModulationTable = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageFormatListCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pViewFormats != nullptr)
    {
        using base_type_t = std::decay_t<const VkFormat>;
        const std::size_t numElements = value.viewFormatCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewFormats, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewFormats = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkValidationCacheCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkShaderModuleValidationCacheCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMaintenance3Properties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMaintenance4Features& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMaintenance4Properties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutSupport& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderDrawParametersFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderFloat16Int8Features& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFloatControlsProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceHostQueryResetFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkShaderResourceUsageAMD& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkShaderStatisticsInfoAMD& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkDeviceQueueGlobalPriorityCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueueFamilyGlobalPriorityPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDebugUtilsObjectNameInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pObjectName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pObjectName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pObjectName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pObjectName = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDebugUtilsObjectTagInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDebugUtilsLabelEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pLabelName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pLabelName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pLabelName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pLabelName = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDebugUtilsMessengerCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDebugUtilsMessengerCallbackDataEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pMessageIdName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pMessageIdName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMessageIdName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMessageIdName = copy;
    }

    if (value.pMessage != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pMessage) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMessage, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMessage = copy;
    }

    if (value.pQueueLabels != nullptr)
    {
        using base_type_t = std::decay_t<const VkDebugUtilsLabelEXT>;
        const std::size_t numElements = value.queueLabelCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pQueueLabels, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pQueueLabels = copy;
    }

    if (value.pCmdBufLabels != nullptr)
    {
        using base_type_t = std::decay_t<const VkDebugUtilsLabelEXT>;
        const std::size_t numElements = value.cmdBufLabelCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCmdBufLabels, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCmdBufLabels = copy;
    }

    if (value.pObjects != nullptr)
    {
        using base_type_t = std::decay_t<const VkDebugUtilsObjectNameInfoEXT>;
        const std::size_t numElements = value.objectCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pObjects, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pObjects = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceDeviceMemoryReportCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceMemoryReportCallbackDataEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMemoryHostPointerInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryHostPointerPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalMemoryHostPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceConservativeRasterizationPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCalibratedTimestampInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderCorePropertiesAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderCoreProperties2AMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationConservativeStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDescriptorIndexingFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDescriptorIndexingProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutBindingFlagsCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pBindingFlags != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorBindingFlags>;
        const std::size_t numElements = value.bindingCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBindingFlags, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBindingFlags = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetVariableDescriptorCountAllocateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDescriptorCounts != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.descriptorSetCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDescriptorCounts, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDescriptorCounts = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetVariableDescriptorCountLayoutSupport& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAttachmentDescription2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAttachmentReference2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubpassDescription2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pInputAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference2>;
        const std::size_t numElements = value.inputAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pInputAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pInputAttachments = copy;
    }

    if (value.pColorAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference2>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorAttachments = copy;
    }

    if (value.pResolveAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference2>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pResolveAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pResolveAttachments = copy;
    }

    if (value.pDepthStencilAttachment != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference2>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDepthStencilAttachment, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDepthStencilAttachment = copy;
    }

    if (value.pPreserveAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.preserveAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPreserveAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPreserveAttachments = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSubpassDependency2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassCreateInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentDescription2>;
        const std::size_t numElements = value.attachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttachments = copy;
    }

    if (value.pSubpasses != nullptr)
    {
        using base_type_t = std::decay_t<const VkSubpassDescription2>;
        const std::size_t numElements = value.subpassCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSubpasses, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSubpasses = copy;
    }

    if (value.pDependencies != nullptr)
    {
        using base_type_t = std::decay_t<const VkSubpassDependency2>;
        const std::size_t numElements = value.dependencyCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDependencies, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDependencies = copy;
    }

    if (value.pCorrelatedViewMasks != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.correlatedViewMaskCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCorrelatedViewMasks, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCorrelatedViewMasks = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSubpassBeginInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubpassEndInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTimelineSemaphoreFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTimelineSemaphoreProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreTypeCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkTimelineSemaphoreSubmitInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pWaitSemaphoreValues != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.waitSemaphoreValueCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitSemaphoreValues, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitSemaphoreValues = copy;
    }

    if (value.pSignalSemaphoreValues != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.signalSemaphoreValueCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSignalSemaphoreValues, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSignalSemaphoreValues = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreWaitInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSemaphores != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphore>;
        const std::size_t numElements = value.semaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSemaphores, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSemaphores = copy;
    }

    if (value.pValues != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.semaphoreCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pValues, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pValues = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreSignalInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVertexInputBindingDivisorDescriptionEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineVertexInputDivisorStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pVertexBindingDivisors != nullptr)
    {
        using base_type_t = std::decay_t<const VkVertexInputBindingDivisorDescriptionEXT>;
        const std::size_t numElements = value.vertexBindingDivisorCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVertexBindingDivisors, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVertexBindingDivisors = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePCIBusInfoPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceConditionalRenderingInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevice8BitStorageFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceConditionalRenderingFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkanMemoryModelFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderAtomicInt64Features& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueueFamilyCheckpointPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCheckpointDataNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDepthStencilResolveProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubpassDescriptionDepthStencilResolve& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDepthStencilResolveAttachment != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference2>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDepthStencilResolveAttachment, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDepthStencilResolveAttachment = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageViewASTCDecodeModeEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceASTCDecodeFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTransformFeedbackFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTransformFeedbackPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationStateStreamCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRepresentativeFragmentTestStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExclusiveScissorFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineViewportExclusiveScissorStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pExclusiveScissors != nullptr)
    {
        using base_type_t = std::decay_t<const VkRect2D>;
        const std::size_t numElements = value.exclusiveScissorCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pExclusiveScissors, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pExclusiveScissors = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCornerSampledImageFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderImageFootprintFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkShadingRatePaletteNV& value)
{
    if (value.pShadingRatePaletteEntries != nullptr)
    {
        using base_type_t = std::decay_t<const VkShadingRatePaletteEntryNV>;
        const std::size_t numElements = value.shadingRatePaletteEntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pShadingRatePaletteEntries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pShadingRatePaletteEntries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineViewportShadingRateImageStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pShadingRatePalettes != nullptr)
    {
        using base_type_t = std::decay_t<const VkShadingRatePaletteNV>;
        const std::size_t numElements = value.viewportCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pShadingRatePalettes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pShadingRatePalettes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShadingRateImageFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShadingRateImagePropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCoarseSampleLocationNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkCoarseSampleOrderCustomNV& value)
{
    if (value.pSampleLocations != nullptr)
    {
        using base_type_t = std::decay_t<const VkCoarseSampleLocationNV>;
        const std::size_t numElements = value.sampleLocationCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSampleLocations, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSampleLocations = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pCustomSampleOrders != nullptr)
    {
        using base_type_t = std::decay_t<const VkCoarseSampleOrderCustomNV>;
        const std::size_t numElements = value.customSampleOrderCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCustomSampleOrders, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCustomSampleOrders = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMeshShaderFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMeshShaderPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDrawMeshTasksIndirectCommandNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkRayTracingShaderGroupCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRayTracingShaderGroupCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRayTracingPipelineCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStages != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineShaderStageCreateInfo>;
        const std::size_t numElements = value.stageCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStages = copy;
    }

    if (value.pGroups != nullptr)
    {
        using base_type_t = std::decay_t<const VkRayTracingShaderGroupCreateInfoNV>;
        const std::size_t numElements = value.groupCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pGroups, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pGroups = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkRayTracingPipelineCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStages != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineShaderStageCreateInfo>;
        const std::size_t numElements = value.stageCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStages = copy;
    }

    if (value.pGroups != nullptr)
    {
        using base_type_t = std::decay_t<const VkRayTracingShaderGroupCreateInfoKHR>;
        const std::size_t numElements = value.groupCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pGroups, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pGroups = copy;
    }

    if (value.pLibraryInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineLibraryCreateInfoKHR>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pLibraryInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pLibraryInfo = copy;
    }

    if (value.pLibraryInterface != nullptr)
    {
        using base_type_t = std::decay_t<const VkRayTracingPipelineInterfaceCreateInfoKHR>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pLibraryInterface, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pLibraryInterface = copy;
    }

    if (value.pDynamicState != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipelineDynamicStateCreateInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDynamicState, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDynamicState = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkGeometryTrianglesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkGeometryAABBNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkGeometryDataNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkGeometryNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pGeometries != nullptr)
    {
        using base_type_t = std::decay_t<const VkGeometryNV>;
        const std::size_t numElements = value.geometryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pGeometries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pGeometries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBindAccelerationStructureMemoryInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDeviceIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.deviceIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDeviceIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDeviceIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSetAccelerationStructureKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAccelerationStructures != nullptr)
    {
        using base_type_t = std::decay_t<const VkAccelerationStructureKHR>;
        const std::size_t numElements = value.accelerationStructureCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAccelerationStructures, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAccelerationStructures = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSetAccelerationStructureNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAccelerationStructures != nullptr)
    {
        using base_type_t = std::decay_t<const VkAccelerationStructureNV>;
        const std::size_t numElements = value.accelerationStructureCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAccelerationStructures, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAccelerationStructures = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMemoryRequirementsInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceAccelerationStructureFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingPipelineFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayQueryFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceAccelerationStructurePropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingPipelinePropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkStridedDeviceAddressRegionKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkTraceRaysIndirectCommandKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkTraceRaysIndirectCommand2KHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierPropertiesListEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDrmFormatModifierProperties != nullptr)
    {
        using base_type_t = std::decay_t<VkDrmFormatModifierPropertiesEXT>;
        const std::size_t numElements = value.drmFormatModifierCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDrmFormatModifierProperties, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDrmFormatModifierProperties = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierPropertiesEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageDrmFormatModifierInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pQueueFamilyIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.queueFamilyIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pQueueFamilyIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageDrmFormatModifierListCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDrmFormatModifiers != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.drmFormatModifierCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDrmFormatModifiers, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDrmFormatModifiers = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageDrmFormatModifierExplicitCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pPlaneLayouts != nullptr)
    {
        using base_type_t = std::decay_t<const VkSubresourceLayout>;
        const std::size_t numElements = value.drmFormatModifierPlaneCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPlaneLayouts, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPlaneLayouts = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageDrmFormatModifierPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageStencilUsageCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceMemoryOverallocationCreateInfoAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassFragmentDensityMapCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubpassFragmentDensityMapOffsetEndInfoQCOM& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pFragmentDensityOffsets != nullptr)
    {
        using base_type_t = std::decay_t<const VkOffset2D>;
        const std::size_t numElements = value.fragmentDensityOffsetCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pFragmentDensityOffsets, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pFragmentDensityOffsets = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceScalarBlockLayoutFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSurfaceProtectedCapabilitiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceUniformBufferStandardLayoutFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDepthClipEnableFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationDepthClipStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryBudgetPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryPriorityFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryPriorityAllocateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBufferDeviceAddressFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferDeviceAddressInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferOpaqueCaptureAddressCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferDeviceAddressCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageViewImageFormatInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFilterCubicImageViewImageFormatPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImagelessFramebufferFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFramebufferAttachmentsCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttachmentImageInfos != nullptr)
    {
        using base_type_t = std::decay_t<const VkFramebufferAttachmentImageInfo>;
        const std::size_t numElements = value.attachmentImageInfoCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttachmentImageInfos, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttachmentImageInfos = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkFramebufferAttachmentImageInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pViewFormats != nullptr)
    {
        using base_type_t = std::decay_t<const VkFormat>;
        const std::size_t numElements = value.viewFormatCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewFormats, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewFormats = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkRenderPassAttachmentBeginInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageView>;
        const std::size_t numElements = value.attachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttachments = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTextureCompressionASTCHDRFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCooperativeMatrixFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCooperativeMatrixPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCooperativeMatrixPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageViewHandleInfoNVX& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageViewAddressPropertiesNVX& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineCreationFeedback& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineCreationFeedbackCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pPipelineCreationFeedback != nullptr)
    {
        using base_type_t = std::decay_t<VkPipelineCreationFeedback>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPipelineCreationFeedback, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPipelineCreationFeedback = copy;
    }

    if (value.pPipelineStageCreationFeedbacks != nullptr)
    {
        using base_type_t = std::decay_t<VkPipelineCreationFeedback>;
        const std::size_t numElements = value.pipelineStageCreationFeedbackCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPipelineStageCreationFeedbacks, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPipelineStageCreationFeedbacks = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePerformanceQueryFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePerformanceQueryPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceCounterKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceCounterDescriptionKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueryPoolPerformanceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pCounterIndices != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.counterIndexCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCounterIndices, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCounterIndices = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAcquireProfilingLockInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceQuerySubmitInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkHeadlessSurfaceCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCoverageReductionModeFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineCoverageReductionStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFramebufferMixedSamplesCombinationNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceValueINTEL& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkInitializePerformanceApiInfoINTEL& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueryPoolPerformanceQueryCreateInfoINTEL& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceMarkerInfoINTEL& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceStreamMarkerInfoINTEL& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceOverrideInfoINTEL& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPerformanceConfigurationAcquireInfoINTEL& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderClockFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceIndexTypeUint8FeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAttachmentReferenceStencilLayout& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAttachmentDescriptionStencilLayout& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineExecutablePropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineExecutableInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineExecutableStatisticKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineExecutableInternalRepresentationKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTexelBufferAlignmentProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubgroupSizeControlFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubgroupSizeControlProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubpassShadingPipelineCreateInfoHUAWEI& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryOpaqueCaptureAddressAllocateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceMemoryOpaqueCaptureAddressInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLineRasterizationFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLineRasterizationPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationLineStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineCreationCacheControlFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan11Features& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan11Properties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan12Features& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan12Properties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan13Features& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan13Properties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineCompilerControlCreateInfoAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCoherentMemoryFeaturesAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceToolProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSamplerCustomBorderColorCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCustomBorderColorPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCustomBorderColorFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSamplerBorderColorComponentMappingCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryTrianglesDataKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryAabbsDataKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryInstancesDataKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureBuildGeometryInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pGeometries != nullptr)
    {
        using base_type_t = std::decay_t<const VkAccelerationStructureGeometryKHR>;
        const std::size_t numElements = value.geometryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pGeometries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pGeometries = copy;
    }

    if (value.ppGeometries != nullptr)
    {
        using base_type_t = std::decay_t<const VkAccelerationStructureGeometryKHR* const>;
        const std::size_t numElements = value.geometryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.ppGeometries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.ppGeometries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureBuildRangeInfoKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAabbPositionsKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkTransformMatrixKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureInstanceKHR& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureDeviceAddressInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureVersionInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pVersionData != nullptr)
    {
        using base_type_t = std::decay_t<const uint8_t>;
        const std::size_t numElements = 2 * VK_UUID_SIZE;
                
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVersionData, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVersionData = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkCopyAccelerationStructureInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCopyAccelerationStructureToMemoryInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCopyMemoryToAccelerationStructureInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRayTracingPipelineInterfaceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineLibraryCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pLibraries != nullptr)
    {
        using base_type_t = std::decay_t<const VkPipeline>;
        const std::size_t numElements = value.libraryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pLibraries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pLibraries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassTransformBeginInfoQCOM& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCopyCommandTransformInfoQCOM& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceRenderPassTransformInfoQCOM& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDiagnosticsConfigFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDeviceDiagnosticsConfigCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRobustness2FeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRobustness2PropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageRobustnessFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevice4444FormatsFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferCopy2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageCopy2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageBlit2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferImageCopy2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageResolve2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCopyBufferInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkBufferCopy2>;
        const std::size_t numElements = value.regionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkCopyImageInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageCopy2>;
        const std::size_t numElements = value.regionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkBlitImageInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageBlit2>;
        const std::size_t numElements = value.regionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkCopyBufferToImageInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkBufferImageCopy2>;
        const std::size_t numElements = value.regionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkCopyImageToBufferInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkBufferImageCopy2>;
        const std::size_t numElements = value.regionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkResolveImageInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRegions != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageResolve2>;
        const std::size_t numElements = value.regionCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRegions = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFragmentShadingRateAttachmentInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pFragmentShadingRateAttachment != nullptr)
    {
        using base_type_t = std::decay_t<const VkAttachmentReference2>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pFragmentShadingRateAttachment, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pFragmentShadingRateAttachment = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPipelineFragmentShadingRateStateCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRatePropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderTerminateInvocationFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineFragmentShadingRateEnumStateCreateInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureBuildSizesInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMutableDescriptorTypeListVALVE& value)
{
    if (value.pDescriptorTypes != nullptr)
    {
        using base_type_t = std::decay_t<const VkDescriptorType>;
        const std::size_t numElements = value.descriptorTypeCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDescriptorTypes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDescriptorTypes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkMutableDescriptorTypeCreateInfoVALVE& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pMutableDescriptorTypeLists != nullptr)
    {
        using base_type_t = std::decay_t<const VkMutableDescriptorTypeListVALVE>;
        const std::size_t numElements = value.mutableDescriptorTypeListCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMutableDescriptorTypeLists, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMutableDescriptorTypeLists = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDepthClipControlFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineViewportDepthClipControlCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVertexInputBindingDescription2EXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVertexInputAttributeDescription2EXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceColorWriteEnableFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineColorWriteCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pColorWriteEnables != nullptr)
    {
        using base_type_t = std::decay_t<const VkBool32>;
        const std::size_t numElements = value.attachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorWriteEnables, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorWriteEnables = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkMemoryBarrier2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageMemoryBarrier2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferMemoryBarrier2& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDependencyInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pMemoryBarriers != nullptr)
    {
        using base_type_t = std::decay_t<const VkMemoryBarrier2>;
        const std::size_t numElements = value.memoryBarrierCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMemoryBarriers, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMemoryBarriers = copy;
    }

    if (value.pBufferMemoryBarriers != nullptr)
    {
        using base_type_t = std::decay_t<const VkBufferMemoryBarrier2>;
        const std::size_t numElements = value.bufferMemoryBarrierCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pBufferMemoryBarriers, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pBufferMemoryBarriers = copy;
    }

    if (value.pImageMemoryBarriers != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageMemoryBarrier2>;
        const std::size_t numElements = value.imageMemoryBarrierCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pImageMemoryBarriers, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pImageMemoryBarriers = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreSubmitInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferSubmitInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubmitInfo2& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pWaitSemaphoreInfos != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphoreSubmitInfo>;
        const std::size_t numElements = value.waitSemaphoreInfoCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitSemaphoreInfos, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitSemaphoreInfos = copy;
    }

    if (value.pCommandBufferInfos != nullptr)
    {
        using base_type_t = std::decay_t<const VkCommandBufferSubmitInfo>;
        const std::size_t numElements = value.commandBufferInfoCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCommandBufferInfos, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCommandBufferInfos = copy;
    }

    if (value.pSignalSemaphoreInfos != nullptr)
    {
        using base_type_t = std::decay_t<const VkSemaphoreSubmitInfo>;
        const std::size_t numElements = value.signalSemaphoreInfoCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSignalSemaphoreInfos, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSignalSemaphoreInfos = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkQueueFamilyCheckpointProperties2NV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCheckpointData2NV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSynchronization2Features& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubpassResolvePerformanceQueryEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMultisampledRenderToSingleSampledInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInheritedViewportScissorFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceViewportScissorInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pViewportDepths != nullptr)
    {
        using base_type_t = std::decay_t<const VkViewport>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pViewportDepths, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pViewportDepths = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProvokingVertexFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProvokingVertexPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCuModuleCreateInfoNVX& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCuFunctionCreateInfoNVX& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pName != nullptr)
    {
        using base_type_t = std::decay_t<const char>;
        const std::size_t numElements = std::strlen(value.pName) + 1;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pName, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pName = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkCuLaunchInfoNVX& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderIntegerDotProductFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderIntegerDotProductProperties& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDrmPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryMotionTrianglesDataNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMotionInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSRTDataNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureSRTMotionInstanceNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMatrixMotionInstanceNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMotionInstanceNV& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkMemoryGetRemoteAddressInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkFormatProperties3& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierPropertiesList2EXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pDrmFormatModifierProperties != nullptr)
    {
        using base_type_t = std::decay_t<VkDrmFormatModifierProperties2EXT>;
        const std::size_t numElements = value.drmFormatModifierCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDrmFormatModifierProperties, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDrmFormatModifierProperties = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierProperties2EXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRenderingCreateInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pColorAttachmentFormats != nullptr)
    {
        using base_type_t = std::decay_t<const VkFormat>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorAttachmentFormats, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorAttachmentFormats = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkRenderingInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pColorAttachments != nullptr)
    {
        using base_type_t = std::decay_t<const VkRenderingAttachmentInfo>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorAttachments, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorAttachments = copy;
    }

    if (value.pDepthAttachment != nullptr)
    {
        using base_type_t = std::decay_t<const VkRenderingAttachmentInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pDepthAttachment, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pDepthAttachment = copy;
    }

    if (value.pStencilAttachment != nullptr)
    {
        using base_type_t = std::decay_t<const VkRenderingAttachmentInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStencilAttachment, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStencilAttachment = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkRenderingAttachmentInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderingFragmentShadingRateAttachmentInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderingFragmentDensityMapAttachmentInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDynamicRenderingFeatures& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceRenderingInfo& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pColorAttachmentFormats != nullptr)
    {
        using base_type_t = std::decay_t<const VkFormat>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorAttachmentFormats, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorAttachmentFormats = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAttachmentSampleCountInfoAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pColorAttachmentSamples != nullptr)
    {
        using base_type_t = std::decay_t<const VkSampleCountFlagBits>;
        const std::size_t numElements = value.colorAttachmentCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorAttachmentSamples, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorAttachmentSamples = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkMultiviewPerViewAttributesInfoNVX& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageViewMinLodFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageViewMinLodCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLinearColorAttachmentFeaturesNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkGraphicsPipelineLibraryCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetBindingReferenceVALVE& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutHostMappingInfoVALVE& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineShaderStageModuleIdentifierCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pIdentifier != nullptr)
    {
        using base_type_t = std::decay_t<const uint8_t>;
        const std::size_t numElements = value.identifierSize;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pIdentifier, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pIdentifier = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkShaderModuleIdentifierEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageCompressionControlEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pFixedRateFlags != nullptr)
    {
        using base_type_t = std::decay_t<VkImageCompressionFixedRateFlagsEXT>;
        const std::size_t numElements = value.compressionControlPlaneCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pFixedRateFlags, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pFixedRateFlags = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageCompressionControlFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageCompressionPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageSubresource2EXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSubresourceLayout2EXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassCreationControlEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassCreationFeedbackInfoEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassCreationFeedbackCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pRenderPassFeedback != nullptr)
    {
        using base_type_t = std::decay_t<VkRenderPassCreationFeedbackInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pRenderPassFeedback, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pRenderPassFeedback = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkRenderPassSubpassFeedbackInfoEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkRenderPassSubpassFeedbackCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSubpassFeedback != nullptr)
    {
        using base_type_t = std::decay_t<VkRenderPassSubpassFeedbackInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSubpassFeedback, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSubpassFeedback = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelinePropertiesIdentifierEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelinePropertiesFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineRobustnessFeaturesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPipelineRobustnessCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineRobustnessPropertiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#if defined(VK_USE_PLATFORM_ANDROID_KHR)

inline void copyIndirectData([[maybe_unused]] VkAndroidSurfaceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.window != nullptr)
    {
        using base_type_t = std::decay_t<struct ANativeWindow>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.window, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.window = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkNativeBufferUsage2ANDROID& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkNativeBufferANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSwapchainImageCreateInfoANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePresentationPropertiesANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportAndroidHardwareBufferInfoANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.buffer != nullptr)
    {
        using base_type_t = std::decay_t<struct AHardwareBuffer>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.buffer, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.buffer = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkAndroidHardwareBufferUsageANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAndroidHardwareBufferPropertiesANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryGetAndroidHardwareBufferInfoANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkAndroidHardwareBufferFormatPropertiesANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExternalFormatANDROID& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_ANDROID_KHR)

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

inline void copyIndirectData([[maybe_unused]] VkDirectFBSurfaceCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.dfb != nullptr)
    {
        using base_type_t = std::decay_t<IDirectFB>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.dfb, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.dfb = copy;
    }

    if (value.surface != nullptr)
    {
        using base_type_t = std::decay_t<IDirectFBSurface>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.surface, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.surface = copy;
    }

}

#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#if defined(VK_USE_PLATFORM_FUCHSIA)

inline void copyIndirectData([[maybe_unused]] VkImagePipeSurfaceCreateInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMemoryZirconHandleInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryZirconHandlePropertiesFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryGetZirconHandleInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportSemaphoreZirconHandleInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreGetZirconHandleInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMemoryBufferCollectionFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferCollectionImageCreateInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferCollectionBufferCreateInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferCollectionCreateInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferCollectionPropertiesFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBufferConstraintsInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSysmemColorSpaceFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImageFormatConstraintsInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pColorSpaces != nullptr)
    {
        using base_type_t = std::decay_t<const VkSysmemColorSpaceFUCHSIA>;
        const std::size_t numElements = value.colorSpaceCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pColorSpaces, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pColorSpaces = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImageConstraintsInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pFormatConstraints != nullptr)
    {
        using base_type_t = std::decay_t<const VkImageFormatConstraintsInfoFUCHSIA>;
        const std::size_t numElements = value.formatConstraintsCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pFormatConstraints, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pFormatConstraints = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkBufferCollectionConstraintsInfoFUCHSIA& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_FUCHSIA)

#if defined(VK_USE_PLATFORM_GGP)

inline void copyIndirectData([[maybe_unused]] VkStreamDescriptorSurfaceCreateInfoGGP& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPresentFrameTokenGGP& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_GGP)

#if defined(VK_USE_PLATFORM_IOS_MVK)

inline void copyIndirectData([[maybe_unused]] VkIOSSurfaceCreateInfoMVK& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_IOS_MVK)

#if defined(VK_USE_PLATFORM_MACOS_MVK)

inline void copyIndirectData([[maybe_unused]] VkMacOSSurfaceCreateInfoMVK& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_MACOS_MVK)

#if defined(VK_USE_PLATFORM_METAL_EXT)

inline void copyIndirectData([[maybe_unused]] VkMetalSurfaceCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pLayer != nullptr)
    {
        using base_type_t = std::decay_t<const CAMetalLayer>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pLayer, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pLayer = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkExportMetalObjectCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMetalObjectsInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMetalDeviceInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMetalCommandQueueInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMetalBufferInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMetalBufferInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMetalTextureInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMetalTextureInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMetalIOSurfaceInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMetalIOSurfaceInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMetalSharedEventInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMetalSharedEventInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_METAL_EXT)

#if defined(VK_ENABLE_BETA_EXTENSIONS)

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePortabilitySubsetFeaturesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePortabilitySubsetPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueueFamilyVideoPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkQueueFamilyQueryResultStatusPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoProfileListInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pProfiles != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoProfileInfoKHR>;
        const std::size_t numElements = value.profileCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pProfiles, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pProfiles = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVideoFormatInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoFormatPropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoProfileInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoCapabilitiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoSessionMemoryRequirementsKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkBindVideoSessionMemoryInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoPictureResourceInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoReferenceSlotInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pPictureResource != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoPictureResourceInfoKHR>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPictureResource, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPictureResource = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeCapabilitiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeUsageInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSetupReferenceSlot != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoReferenceSlotInfoKHR>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSetupReferenceSlot, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSetupReferenceSlot = copy;
    }

    if (value.pReferenceSlots != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoReferenceSlotInfoKHR>;
        const std::size_t numElements = value.referenceSlotCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceSlots, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceSlots = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264ProfileInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264CapabilitiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264SessionParametersAddInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH264SequenceParameterSet>;
        const std::size_t numElements = value.spsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSpsStd = copy;
    }

    if (value.pPpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH264PictureParameterSet>;
        const std::size_t numElements = value.ppsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPpsStd = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264SessionParametersCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pParametersAddInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoDecodeH264SessionParametersAddInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pParametersAddInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264PictureInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStdPictureInfo != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoDecodeH264PictureInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdPictureInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdPictureInfo = copy;
    }

    if (value.pSlicesDataOffsets != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.slicesCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSlicesDataOffsets, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSlicesDataOffsets = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264DpbSlotInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStdReferenceInfo != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoDecodeH264ReferenceInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdReferenceInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264MvcInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStdMvc != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoDecodeH264Mvc>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdMvc, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdMvc = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265ProfileInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265CapabilitiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265SessionParametersAddInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pVpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH265VideoParameterSet>;
        const std::size_t numElements = value.vpsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVpsStd = copy;
    }

    if (value.pSpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH265SequenceParameterSet>;
        const std::size_t numElements = value.spsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSpsStd = copy;
    }

    if (value.pPpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH265PictureParameterSet>;
        const std::size_t numElements = value.ppsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPpsStd = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265SessionParametersCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pParametersAddInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoDecodeH265SessionParametersAddInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pParametersAddInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265PictureInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStdPictureInfo != nullptr)
    {
        using base_type_t = std::decay_t<StdVideoDecodeH265PictureInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdPictureInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdPictureInfo = copy;
    }

    if (value.pSlicesDataOffsets != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.slicesCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSlicesDataOffsets, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSlicesDataOffsets = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265DpbSlotInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStdReferenceInfo != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoDecodeH265ReferenceInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdReferenceInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoSessionCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pVideoProfile != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoProfileInfoKHR>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVideoProfile, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVideoProfile = copy;
    }

    if (value.pStdHeaderVersion != nullptr)
    {
        using base_type_t = std::decay_t<const VkExtensionProperties>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdHeaderVersion, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdHeaderVersion = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoSessionParametersCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoSessionParametersUpdateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoBeginCodingInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pReferenceSlots != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoReferenceSlotInfoKHR>;
        const std::size_t numElements = value.referenceSlotCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceSlots, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceSlots = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEndCodingInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoCodingControlInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeUsageInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSetupReferenceSlot != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoReferenceSlotInfoKHR>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSetupReferenceSlot, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSetupReferenceSlot = copy;
    }

    if (value.pReferenceSlots != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoReferenceSlotInfoKHR>;
        const std::size_t numElements = value.referenceSlotCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceSlots, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceSlots = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeRateControlInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pLayerConfigs != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeRateControlLayerInfoKHR>;
        const std::size_t numElements = value.layerCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pLayerConfigs, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pLayerConfigs = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeRateControlLayerInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeCapabilitiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264CapabilitiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264SessionParametersAddInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pSpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH264SequenceParameterSet>;
        const std::size_t numElements = value.spsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSpsStd = copy;
    }

    if (value.pPpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH264PictureParameterSet>;
        const std::size_t numElements = value.ppsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPpsStd = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264SessionParametersCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pParametersAddInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH264SessionParametersAddInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pParametersAddInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264DpbSlotInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStdReferenceInfo != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH264ReferenceInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdReferenceInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264VclFrameInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pReferenceFinalLists != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH264ReferenceListsInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceFinalLists = copy;
    }

    if (value.pNaluSliceEntries != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH264NaluSliceInfoEXT>;
        const std::size_t numElements = value.naluSliceEntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pNaluSliceEntries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pNaluSliceEntries = copy;
    }

    if (value.pCurrentPictureInfo != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH264PictureInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCurrentPictureInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCurrentPictureInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264ReferenceListsInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pReferenceList0Entries != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH264DpbSlotInfoEXT>;
        const std::size_t numElements = value.referenceList0EntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceList0Entries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceList0Entries = copy;
    }

    if (value.pReferenceList1Entries != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH264DpbSlotInfoEXT>;
        const std::size_t numElements = value.referenceList1EntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceList1Entries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceList1Entries = copy;
    }

    if (value.pMemMgmtCtrlOperations != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH264RefMemMgmtCtrlOperations>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pMemMgmtCtrlOperations, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pMemMgmtCtrlOperations = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264EmitPictureParametersInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.ppsIdEntries != nullptr)
    {
        using base_type_t = std::decay_t<const uint8_t>;
        const std::size_t numElements = value.ppsIdEntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.ppsIdEntries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.ppsIdEntries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264ProfileInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264NaluSliceInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pReferenceFinalLists != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH264ReferenceListsInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceFinalLists = copy;
    }

    if (value.pSliceHeaderStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH264SliceHeader>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSliceHeaderStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSliceHeaderStd = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264RateControlInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264QpEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264FrameSizeEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264RateControlLayerInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265CapabilitiesEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265SessionParametersAddInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pVpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH265VideoParameterSet>;
        const std::size_t numElements = value.vpsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pVpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pVpsStd = copy;
    }

    if (value.pSpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH265SequenceParameterSet>;
        const std::size_t numElements = value.spsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSpsStd = copy;
    }

    if (value.pPpsStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoH265PictureParameterSet>;
        const std::size_t numElements = value.ppsStdCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pPpsStd = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265SessionParametersCreateInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pParametersAddInfo != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH265SessionParametersAddInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pParametersAddInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265VclFrameInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pReferenceFinalLists != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH265ReferenceListsInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceFinalLists = copy;
    }

    if (value.pNaluSliceSegmentEntries != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH265NaluSliceSegmentInfoEXT>;
        const std::size_t numElements = value.naluSliceSegmentEntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pNaluSliceSegmentEntries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pNaluSliceSegmentEntries = copy;
    }

    if (value.pCurrentPictureInfo != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH265PictureInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pCurrentPictureInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pCurrentPictureInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265EmitPictureParametersInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.ppsIdEntries != nullptr)
    {
        using base_type_t = std::decay_t<const uint8_t>;
        const std::size_t numElements = value.ppsIdEntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.ppsIdEntries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.ppsIdEntries = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265NaluSliceSegmentInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pReferenceFinalLists != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH265ReferenceListsInfoEXT>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceFinalLists = copy;
    }

    if (value.pSliceSegmentHeaderStd != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH265SliceSegmentHeader>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSliceSegmentHeaderStd, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSliceSegmentHeaderStd = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265RateControlInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265QpEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265FrameSizeEXT& value)
{
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265RateControlLayerInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265ProfileInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265DpbSlotInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pStdReferenceInfo != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH265ReferenceInfo>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pStdReferenceInfo = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265ReferenceListsInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pReferenceList0Entries != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH265DpbSlotInfoEXT>;
        const std::size_t numElements = value.referenceList0EntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceList0Entries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceList0Entries = copy;
    }

    if (value.pReferenceList1Entries != nullptr)
    {
        using base_type_t = std::decay_t<const VkVideoEncodeH265DpbSlotInfoEXT>;
        const std::size_t numElements = value.referenceList1EntryCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceList1Entries, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceList1Entries = copy;
    }

    if (value.pReferenceModifications != nullptr)
    {
        using base_type_t = std::decay_t<const StdVideoEncodeH265ReferenceModifications>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReferenceModifications, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReferenceModifications = copy;
    }

}

#endif // defined(VK_ENABLE_BETA_EXTENSIONS)

#if defined(VK_USE_PLATFORM_SCREEN_QNX)

inline void copyIndirectData([[maybe_unused]] VkScreenSurfaceCreateInfoQNX& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.context != nullptr)
    {
        using base_type_t = std::decay_t<struct _screen_context>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.context, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.context = copy;
    }

    if (value.window != nullptr)
    {
        using base_type_t = std::decay_t<struct _screen_window>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.window, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.window = copy;
    }

}

#endif // defined(VK_USE_PLATFORM_SCREEN_QNX)

#if defined(VK_USE_PLATFORM_VI_NN)

inline void copyIndirectData([[maybe_unused]] VkViSurfaceCreateInfoNN& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_VI_NN)

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

inline void copyIndirectData([[maybe_unused]] VkWaylandSurfaceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.display != nullptr)
    {
        using base_type_t = std::decay_t<struct wl_display>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.display, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.display = copy;
    }

    if (value.surface != nullptr)
    {
        using base_type_t = std::decay_t<struct wl_surface>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.surface, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.surface = copy;
    }

}

#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR)

#if defined(VK_USE_PLATFORM_WIN32_KHR)

inline void copyIndirectData([[maybe_unused]] VkWin32SurfaceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportMemoryWin32HandleInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMemoryWin32HandleInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttributes != nullptr)
    {
        using base_type_t = std::decay_t<const SECURITY_ATTRIBUTES>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttributes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkWin32KeyedMutexAcquireReleaseInfoNV& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAcquireSyncs != nullptr)
    {
        using base_type_t = std::decay_t<const VkDeviceMemory>;
        const std::size_t numElements = value.acquireCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAcquireSyncs, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAcquireSyncs = copy;
    }

    if (value.pAcquireKeys != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.acquireCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAcquireKeys, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAcquireKeys = copy;
    }

    if (value.pAcquireTimeoutMilliseconds != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.acquireCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAcquireTimeoutMilliseconds, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAcquireTimeoutMilliseconds = copy;
    }

    if (value.pReleaseSyncs != nullptr)
    {
        using base_type_t = std::decay_t<const VkDeviceMemory>;
        const std::size_t numElements = value.releaseCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReleaseSyncs, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReleaseSyncs = copy;
    }

    if (value.pReleaseKeys != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.releaseCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReleaseKeys, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReleaseKeys = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImportMemoryWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportMemoryWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttributes != nullptr)
    {
        using base_type_t = std::decay_t<const SECURITY_ATTRIBUTES>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttributes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkMemoryWin32HandlePropertiesKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkMemoryGetWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkWin32KeyedMutexAcquireReleaseInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAcquireSyncs != nullptr)
    {
        using base_type_t = std::decay_t<const VkDeviceMemory>;
        const std::size_t numElements = value.acquireCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAcquireSyncs, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAcquireSyncs = copy;
    }

    if (value.pAcquireKeys != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.acquireCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAcquireKeys, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAcquireKeys = copy;
    }

    if (value.pAcquireTimeouts != nullptr)
    {
        using base_type_t = std::decay_t<const uint32_t>;
        const std::size_t numElements = value.acquireCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAcquireTimeouts, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAcquireTimeouts = copy;
    }

    if (value.pReleaseSyncs != nullptr)
    {
        using base_type_t = std::decay_t<const VkDeviceMemory>;
        const std::size_t numElements = value.releaseCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReleaseSyncs, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReleaseSyncs = copy;
    }

    if (value.pReleaseKeys != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.releaseCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pReleaseKeys, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pReleaseKeys = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkImportSemaphoreWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportSemaphoreWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttributes != nullptr)
    {
        using base_type_t = std::decay_t<const SECURITY_ATTRIBUTES>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttributes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkD3D12FenceSubmitInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pWaitSemaphoreValues != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.waitSemaphoreValuesCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pWaitSemaphoreValues, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pWaitSemaphoreValues = copy;
    }

    if (value.pSignalSemaphoreValues != nullptr)
    {
        using base_type_t = std::decay_t<const uint64_t>;
        const std::size_t numElements = value.signalSemaphoreValuesCount;
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pSignalSemaphoreValues, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pSignalSemaphoreValues = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkSemaphoreGetWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkImportFenceWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkExportFenceWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.pAttributes != nullptr)
    {
        using base_type_t = std::decay_t<const SECURITY_ATTRIBUTES>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.pAttributes = copy;
    }

}

inline void copyIndirectData([[maybe_unused]] VkFenceGetWin32HandleInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSurfaceFullScreenExclusiveInfoEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilitiesFullScreenExclusiveEXT& value)
{
    value.pNext = copyNextPtr(value.pNext);
}

#endif // defined(VK_USE_PLATFORM_WIN32_KHR)

#if defined(VK_USE_PLATFORM_XCB_KHR)

inline void copyIndirectData([[maybe_unused]] VkXcbSurfaceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.connection != nullptr)
    {
        using base_type_t = std::decay_t<xcb_connection_t>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.connection, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.connection = copy;
    }

}

#endif // defined(VK_USE_PLATFORM_XCB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_KHR)

inline void copyIndirectData([[maybe_unused]] VkXlibSurfaceCreateInfoKHR& value)
{
    value.pNext = copyNextPtr(value.pNext);
    if (value.dpy != nullptr)
    {
        using base_type_t = std::decay_t<Display>;
        static constexpr std::size_t numElements = 1; // TODO
        auto copy = allocType<base_type_t>(numElements);
        std::memcpy(copy, value.dpy, numElements * sizeof(base_type_t));

        for (std::size_t ele = 0; ele < numElements; ++ele) {
            copyIndirectData(copy[ele]);
        }
        value.dpy = copy;
    }

}
#endif // defined(VK_USE_PLATFORM_XLIB_KHR)

inline void variantWrap(VkInstance value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_INSTANCE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkPhysicalDevice value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_PHYSICAL_DEVICE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDevice value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DEVICE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkQueue value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_QUEUE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkCommandBuffer value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_COMMAND_BUFFER;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDeviceMemory value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DEVICE_MEMORY;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkCommandPool value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_COMMAND_POOL;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkBuffer value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_BUFFER;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkBufferView value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_BUFFER_VIEW;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkImage value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_IMAGE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkImageView value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_IMAGE_VIEW;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkShaderModule value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_SHADER_MODULE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkPipeline value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_PIPELINE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkPipelineLayout value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_PIPELINE_LAYOUT;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkSampler value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_SAMPLER;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDescriptorSet value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_SET;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDescriptorSetLayout value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDescriptorPool value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_POOL;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkFence value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_FENCE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkSemaphore value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_SEMAPHORE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkEvent value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_EVENT;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkQueryPool value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_QUERY_POOL;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkFramebuffer value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_FRAMEBUFFER;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkRenderPass value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_RENDER_PASS;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkPipelineCache value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_PIPELINE_CACHE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkIndirectCommandsLayoutNV value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDescriptorUpdateTemplate value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkSamplerYcbcrConversion value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkValidationCacheEXT value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkAccelerationStructureKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkAccelerationStructureNV value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkPerformanceConfigurationINTEL value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDeferredOperationKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkPrivateDataSlot value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkCuModuleNVX value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_CU_MODULE_NVX;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkCuFunctionNVX value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_CU_FUNCTION_NVX;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDisplayKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DISPLAY_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDisplayModeKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DISPLAY_MODE_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkSurfaceKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_SURFACE_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkSwapchainKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_SWAPCHAIN_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDebugReportCallbackEXT value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkDebugUtilsMessengerEXT value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT;
    outVariant.objectValue.value = value;
}

inline void variantWrap(const VkBaseOutStructure& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBaseOutStructure>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBaseOutStructure));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBaseInStructure& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBaseInStructure>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBaseInStructure));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkApplicationInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkApplicationInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkApplicationInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceQueueCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceQueueCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceQueueCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkInstanceCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkInstanceCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkInstanceCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryAllocateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryAllocateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryAllocateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMappedMemoryRange& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMappedMemoryRange>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMappedMemoryRange));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkWriteDescriptorSet& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWriteDescriptorSet>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSet));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyDescriptorSet& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyDescriptorSet>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyDescriptorSet));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferViewCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferViewCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferViewCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryBarrier& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryBarrier>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryBarrier));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferMemoryBarrier& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferMemoryBarrier>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferMemoryBarrier));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageMemoryBarrier& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageMemoryBarrier>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageMemoryBarrier));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageViewCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageViewCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageViewCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindSparseInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindSparseInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindSparseInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkShaderModuleCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkShaderModuleCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkShaderModuleCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetLayoutCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetLayoutCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorPoolCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorPoolCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorPoolCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetAllocateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetAllocateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetAllocateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineShaderStageCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineShaderStageCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineShaderStageCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkComputePipelineCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkComputePipelineCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkComputePipelineCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineVertexInputStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineVertexInputStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineVertexInputStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineInputAssemblyStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineInputAssemblyStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineInputAssemblyStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineTessellationStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineTessellationStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineTessellationStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineViewportStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineViewportStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRasterizationStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRasterizationStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineMultisampleStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineMultisampleStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineMultisampleStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineColorBlendStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineColorBlendStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineColorBlendStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineDynamicStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineDynamicStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineDynamicStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineDepthStencilStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineDepthStencilStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineDepthStencilStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGraphicsPipelineCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGraphicsPipelineCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGraphicsPipelineCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineCacheCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineCacheCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineCacheCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineLayoutCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineLayoutCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineLayoutCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSamplerCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSamplerCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSamplerCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandPoolCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandPoolCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandPoolCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferAllocateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferAllocateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferAllocateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferInheritanceInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferInheritanceInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferBeginInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferBeginInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferBeginInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassBeginInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassBeginInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassBeginInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkEventCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkEventCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkEventCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFenceCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFenceCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFenceCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueryPoolCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueryPoolCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueryPoolCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFramebufferCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFramebufferCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFramebufferCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubmitInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubmitInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubmitInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayModeCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayModeCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayModeCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplaySurfaceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplaySurfaceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplaySurfaceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayPresentInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayPresentInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayPresentInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSwapchainCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSwapchainCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSwapchainCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPresentInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPresentInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPresentInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugReportCallbackCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugReportCallbackCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugReportCallbackCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkValidationFlagsEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkValidationFlagsEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkValidationFlagsEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkValidationFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkValidationFeaturesEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkValidationFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRasterizationStateRasterizationOrderAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRasterizationStateRasterizationOrderAMD>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationStateRasterizationOrderAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugMarkerObjectNameInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugMarkerObjectNameInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugMarkerObjectNameInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugMarkerObjectTagInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugMarkerObjectTagInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugMarkerObjectTagInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugMarkerMarkerInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugMarkerMarkerInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugMarkerMarkerInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDedicatedAllocationImageCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDedicatedAllocationImageCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDedicatedAllocationImageCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDedicatedAllocationBufferCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDedicatedAllocationBufferCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDedicatedAllocationBufferCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDedicatedAllocationMemoryAllocateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDedicatedAllocationMemoryAllocateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDedicatedAllocationMemoryAllocateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalMemoryImageCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalMemoryImageCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalMemoryImageCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMemoryAllocateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMemoryAllocateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMemoryAllocateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDevicePrivateDataCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDevicePrivateDataCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDevicePrivateDataCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPrivateDataSlotCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPrivateDataSlotCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPrivateDataSlotCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePrivateDataFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePrivateDataFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePrivateDataFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMultiDrawPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMultiDrawPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGraphicsShaderGroupCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGraphicsShaderGroupCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGraphicsShaderGroupCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGraphicsPipelineShaderGroupsCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGraphicsPipelineShaderGroupsCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGraphicsPipelineShaderGroupsCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkIndirectCommandsLayoutTokenNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkIndirectCommandsLayoutTokenNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkIndirectCommandsLayoutTokenNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkIndirectCommandsLayoutCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkIndirectCommandsLayoutCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkIndirectCommandsLayoutCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGeneratedCommandsInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGeneratedCommandsInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGeneratedCommandsInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGeneratedCommandsMemoryRequirementsInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGeneratedCommandsMemoryRequirementsInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGeneratedCommandsMemoryRequirementsInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFeatures2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFeatures2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFeatures2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceProperties2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceProperties2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProperties2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFormatProperties2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFormatProperties2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFormatProperties2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageFormatProperties2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageFormatProperties2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageFormatProperties2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImageFormatInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImageFormatInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageFormatInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueueFamilyProperties2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueueFamilyProperties2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyProperties2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMemoryProperties2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMemoryProperties2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMemoryProperties2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSparseImageFormatProperties2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSparseImageFormatProperties2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSparseImageFormatProperties2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSparseImageFormatInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSparseImageFormatInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSparseImageFormatInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePushDescriptorPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePushDescriptorPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDriverProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDriverProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDriverProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPresentRegionsKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPresentRegionsKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPresentRegionsKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVariablePointersFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVariablePointersFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVariablePointersFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExternalImageFormatInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExternalImageFormatInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalImageFormatInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalImageFormatProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalImageFormatProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalImageFormatProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExternalBufferInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExternalBufferInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalBufferInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalBufferProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalBufferProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalBufferProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceIDProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceIDProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceIDProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalMemoryImageCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalMemoryImageCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalMemoryImageCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalMemoryBufferCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalMemoryBufferCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalMemoryBufferCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMemoryAllocateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMemoryAllocateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMemoryAllocateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMemoryFdInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMemoryFdInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMemoryFdInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryFdPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryFdPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryFdPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryGetFdInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryGetFdInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryGetFdInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExternalSemaphoreInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExternalSemaphoreInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalSemaphoreInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalSemaphoreProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalSemaphoreProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalSemaphoreProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportSemaphoreCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportSemaphoreCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportSemaphoreCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportSemaphoreFdInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportSemaphoreFdInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportSemaphoreFdInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreGetFdInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreGetFdInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreGetFdInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExternalFenceInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExternalFenceInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalFenceInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalFenceProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalFenceProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalFenceProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportFenceCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportFenceCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportFenceCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportFenceFdInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportFenceFdInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportFenceFdInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFenceGetFdInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFenceGetFdInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFenceGetFdInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMultiviewFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMultiviewFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiviewFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMultiviewProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMultiviewProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiviewProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassMultiviewCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassMultiviewCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassMultiviewCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSurfaceCapabilities2EXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSurfaceCapabilities2EXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSurfaceCapabilities2EXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayPowerInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayPowerInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayPowerInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceEventInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceEventInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceEventInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayEventInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayEventInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayEventInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSwapchainCounterCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSwapchainCounterCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSwapchainCounterCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceGroupProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceGroupProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGroupProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryAllocateFlagsInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryAllocateFlagsInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryAllocateFlagsInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindBufferMemoryInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindBufferMemoryInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindBufferMemoryInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindBufferMemoryDeviceGroupInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindBufferMemoryDeviceGroupInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindBufferMemoryDeviceGroupInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindImageMemoryInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindImageMemoryInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindImageMemoryInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindImageMemoryDeviceGroupInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindImageMemoryDeviceGroupInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindImageMemoryDeviceGroupInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupRenderPassBeginInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupRenderPassBeginInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupRenderPassBeginInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupCommandBufferBeginInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupCommandBufferBeginInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupCommandBufferBeginInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupSubmitInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupSubmitInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupSubmitInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupBindSparseInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupBindSparseInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupBindSparseInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupPresentCapabilitiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupPresentCapabilitiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupPresentCapabilitiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageSwapchainCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageSwapchainCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageSwapchainCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindImageMemorySwapchainInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindImageMemorySwapchainInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindImageMemorySwapchainInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAcquireNextImageInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAcquireNextImageInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAcquireNextImageInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupPresentInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupPresentInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupPresentInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupDeviceCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupDeviceCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupDeviceCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceGroupSwapchainCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceGroupSwapchainCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupSwapchainCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorUpdateTemplateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorUpdateTemplateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorUpdateTemplateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePresentIdFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePresentIdFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePresentIdFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPresentIdKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPresentIdKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPresentIdKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePresentWaitFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePresentWaitFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePresentWaitFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkHdrMetadataEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkHdrMetadataEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkHdrMetadataEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayNativeHdrSurfaceCapabilitiesAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayNativeHdrSurfaceCapabilitiesAMD>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSwapchainDisplayNativeHdrCreateInfoAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSwapchainDisplayNativeHdrCreateInfoAMD>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPresentTimesInfoGOOGLE& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPresentTimesInfoGOOGLE>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPresentTimesInfoGOOGLE));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineViewportWScalingStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineViewportWScalingStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportWScalingStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineViewportSwizzleStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineViewportSwizzleStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportSwizzleStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDiscardRectanglePropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDiscardRectanglePropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineDiscardRectangleStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineDiscardRectangleStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassInputAttachmentAspectCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassInputAttachmentAspectCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassInputAttachmentAspectCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSurfaceInfo2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSurfaceInfo2KHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSurfaceInfo2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSurfaceCapabilities2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSurfaceCapabilities2KHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSurfaceCapabilities2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSurfaceFormat2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSurfaceFormat2KHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSurfaceFormat2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayProperties2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayProperties2KHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayProperties2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayPlaneProperties2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayPlaneProperties2KHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayPlaneProperties2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayModeProperties2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayModeProperties2KHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayModeProperties2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayPlaneInfo2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayPlaneInfo2KHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayPlaneInfo2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDisplayPlaneCapabilities2KHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDisplayPlaneCapabilities2KHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDisplayPlaneCapabilities2KHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSharedPresentSurfaceCapabilitiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSharedPresentSurfaceCapabilitiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSharedPresentSurfaceCapabilitiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevice16BitStorageFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevice16BitStorageFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevice16BitStorageFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSubgroupProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSubgroupProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubgroupProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferMemoryRequirementsInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferMemoryRequirementsInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferMemoryRequirementsInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceBufferMemoryRequirements& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceBufferMemoryRequirements>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceBufferMemoryRequirements));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageMemoryRequirementsInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageMemoryRequirementsInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageMemoryRequirementsInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageSparseMemoryRequirementsInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageSparseMemoryRequirementsInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageSparseMemoryRequirementsInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceImageMemoryRequirements& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceImageMemoryRequirements>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceImageMemoryRequirements));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryRequirements2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryRequirements2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryRequirements2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSparseImageMemoryRequirements2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSparseImageMemoryRequirements2>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSparseImageMemoryRequirements2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePointClippingProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePointClippingProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePointClippingProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryDedicatedRequirements& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryDedicatedRequirements>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryDedicatedRequirements));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryDedicatedAllocateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryDedicatedAllocateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryDedicatedAllocateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageViewUsageCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageViewUsageCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageViewUsageCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineTessellationDomainOriginStateCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineTessellationDomainOriginStateCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineTessellationDomainOriginStateCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSamplerYcbcrConversionInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSamplerYcbcrConversionInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSamplerYcbcrConversionInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSamplerYcbcrConversionCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSamplerYcbcrConversionCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSamplerYcbcrConversionCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindImagePlaneMemoryInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindImagePlaneMemoryInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindImagePlaneMemoryInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImagePlaneMemoryRequirementsInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImagePlaneMemoryRequirementsInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImagePlaneMemoryRequirementsInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSamplerYcbcrConversionFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSamplerYcbcrConversionFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSamplerYcbcrConversionImageFormatProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSamplerYcbcrConversionImageFormatProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSamplerYcbcrConversionImageFormatProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkTextureLODGatherFormatPropertiesAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkTextureLODGatherFormatPropertiesAMD>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkTextureLODGatherFormatPropertiesAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkConditionalRenderingBeginInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkConditionalRenderingBeginInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkConditionalRenderingBeginInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkProtectedSubmitInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkProtectedSubmitInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkProtectedSubmitInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceProtectedMemoryFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceProtectedMemoryFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceProtectedMemoryProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceProtectedMemoryProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProtectedMemoryProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceQueueInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceQueueInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceQueueInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineCoverageToColorStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineCoverageToColorStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineCoverageToColorStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSamplerFilterMinmaxProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSamplerFilterMinmaxProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSampleLocationsInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSampleLocationsInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSampleLocationsInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassSampleLocationsBeginInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassSampleLocationsBeginInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassSampleLocationsBeginInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineSampleLocationsStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineSampleLocationsStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineSampleLocationsStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSampleLocationsPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSampleLocationsPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMultisamplePropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMultisamplePropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMultisamplePropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSamplerReductionModeCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSamplerReductionModeCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSamplerReductionModeCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMultiDrawFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMultiDrawFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineColorBlendAdvancedStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineColorBlendAdvancedStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceInlineUniformBlockFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceInlineUniformBlockFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInlineUniformBlockFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceInlineUniformBlockProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceInlineUniformBlockProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInlineUniformBlockProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkWriteDescriptorSetInlineUniformBlock& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWriteDescriptorSetInlineUniformBlock>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSetInlineUniformBlock));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorPoolInlineUniformBlockCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorPoolInlineUniformBlockCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineCoverageModulationStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineCoverageModulationStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineCoverageModulationStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageFormatListCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageFormatListCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageFormatListCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkValidationCacheCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkValidationCacheCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkValidationCacheCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkShaderModuleValidationCacheCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkShaderModuleValidationCacheCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkShaderModuleValidationCacheCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMaintenance3Properties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMaintenance3Properties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMaintenance3Properties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMaintenance4Features& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMaintenance4Features>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMaintenance4Features));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMaintenance4Properties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMaintenance4Properties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMaintenance4Properties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetLayoutSupport& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetLayoutSupport>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutSupport));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderDrawParametersFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderDrawParametersFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderFloat16Int8Features& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderFloat16Int8Features>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderFloat16Int8Features));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFloatControlsProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFloatControlsProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFloatControlsProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceHostQueryResetFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceHostQueryResetFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceHostQueryResetFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceQueueGlobalPriorityCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceQueueGlobalPriorityCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceQueueGlobalPriorityCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueueFamilyGlobalPriorityPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueueFamilyGlobalPriorityPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyGlobalPriorityPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugUtilsObjectNameInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugUtilsObjectNameInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsObjectNameInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugUtilsObjectTagInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugUtilsObjectTagInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsObjectTagInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugUtilsLabelEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugUtilsLabelEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsLabelEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugUtilsMessengerCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugUtilsMessengerCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsMessengerCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDebugUtilsMessengerCallbackDataEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDebugUtilsMessengerCallbackDataEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsMessengerCallbackDataEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceDeviceMemoryReportCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceDeviceMemoryReportCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceDeviceMemoryReportCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceMemoryReportCallbackDataEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceMemoryReportCallbackDataEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceMemoryReportCallbackDataEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMemoryHostPointerInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMemoryHostPointerInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMemoryHostPointerInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryHostPointerPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryHostPointerPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryHostPointerPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExternalMemoryHostPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCalibratedTimestampInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCalibratedTimestampInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCalibratedTimestampInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderCorePropertiesAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderCorePropertiesAMD>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderCorePropertiesAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderCoreProperties2AMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderCoreProperties2AMD>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderCoreProperties2AMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRasterizationConservativeStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRasterizationConservativeStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDescriptorIndexingFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDescriptorIndexingFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDescriptorIndexingProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDescriptorIndexingProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDescriptorIndexingProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetLayoutBindingFlagsCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetLayoutBindingFlagsCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetVariableDescriptorCountAllocateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetVariableDescriptorCountAllocateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetVariableDescriptorCountLayoutSupport& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetVariableDescriptorCountLayoutSupport>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAttachmentDescription2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAttachmentDescription2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAttachmentDescription2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAttachmentReference2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAttachmentReference2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAttachmentReference2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassDescription2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassDescription2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassDescription2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassDependency2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassDependency2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassDependency2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassCreateInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassCreateInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreateInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassBeginInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassBeginInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassBeginInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassEndInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassEndInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassEndInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceTimelineSemaphoreFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceTimelineSemaphoreFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceTimelineSemaphoreProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceTimelineSemaphoreProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTimelineSemaphoreProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreTypeCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreTypeCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreTypeCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkTimelineSemaphoreSubmitInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkTimelineSemaphoreSubmitInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkTimelineSemaphoreSubmitInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreWaitInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreWaitInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreWaitInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreSignalInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreSignalInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreSignalInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineVertexInputDivisorStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineVertexInputDivisorStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePCIBusInfoPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePCIBusInfoPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferInheritanceConditionalRenderingInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferInheritanceConditionalRenderingInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevice8BitStorageFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevice8BitStorageFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevice8BitStorageFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceConditionalRenderingFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVulkanMemoryModelFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVulkanMemoryModelFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderAtomicInt64Features& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderAtomicInt64Features>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderAtomicInt64Features));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueueFamilyCheckpointPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueueFamilyCheckpointPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyCheckpointPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCheckpointDataNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCheckpointDataNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCheckpointDataNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDepthStencilResolveProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDepthStencilResolveProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDepthStencilResolveProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassDescriptionDepthStencilResolve& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassDescriptionDepthStencilResolve>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassDescriptionDepthStencilResolve));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageViewASTCDecodeModeEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageViewASTCDecodeModeEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageViewASTCDecodeModeEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceASTCDecodeFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceASTCDecodeFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceTransformFeedbackFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceTransformFeedbackPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceTransformFeedbackPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRasterizationStateStreamCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRasterizationStateStreamCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRepresentativeFragmentTestStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExclusiveScissorFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExclusiveScissorFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExclusiveScissorFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineViewportExclusiveScissorStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineViewportExclusiveScissorStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceCornerSampledImageFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceCornerSampledImageFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCornerSampledImageFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderImageFootprintFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderImageFootprintFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineViewportShadingRateImageStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineViewportShadingRateImageStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportShadingRateImageStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShadingRateImageFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShadingRateImageFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShadingRateImageFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShadingRateImagePropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShadingRateImagePropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShadingRateImagePropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMeshShaderFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMeshShaderFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMeshShaderFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMeshShaderPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMeshShaderPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMeshShaderPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRayTracingShaderGroupCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRayTracingShaderGroupCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRayTracingShaderGroupCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRayTracingShaderGroupCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRayTracingShaderGroupCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRayTracingShaderGroupCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRayTracingPipelineCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRayTracingPipelineCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRayTracingPipelineCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRayTracingPipelineCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRayTracingPipelineCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRayTracingPipelineCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGeometryTrianglesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGeometryTrianglesNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGeometryTrianglesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGeometryAABBNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGeometryAABBNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGeometryAABBNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGeometryNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGeometryNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGeometryNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindAccelerationStructureMemoryInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindAccelerationStructureMemoryInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindAccelerationStructureMemoryInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkWriteDescriptorSetAccelerationStructureKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWriteDescriptorSetAccelerationStructureKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSetAccelerationStructureKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkWriteDescriptorSetAccelerationStructureNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWriteDescriptorSetAccelerationStructureNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSetAccelerationStructureNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureMemoryRequirementsInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureMemoryRequirementsInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureMemoryRequirementsInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceAccelerationStructureFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceAccelerationStructureFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRayQueryFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRayQueryFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayQueryFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceAccelerationStructurePropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceAccelerationStructurePropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRayTracingPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRayTracingPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDrmFormatModifierPropertiesListEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDrmFormatModifierPropertiesListEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDrmFormatModifierPropertiesListEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageDrmFormatModifierListCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageDrmFormatModifierListCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageDrmFormatModifierListCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageDrmFormatModifierExplicitCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageDrmFormatModifierExplicitCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageDrmFormatModifierPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageDrmFormatModifierPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageDrmFormatModifierPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageStencilUsageCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageStencilUsageCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageStencilUsageCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceMemoryOverallocationCreateInfoAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceMemoryOverallocationCreateInfoAMD>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceMemoryOverallocationCreateInfoAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentDensityMapPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassFragmentDensityMapCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassFragmentDensityMapCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassFragmentDensityMapOffsetEndInfoQCOM>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassFragmentDensityMapOffsetEndInfoQCOM));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceScalarBlockLayoutFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceScalarBlockLayoutFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSurfaceProtectedCapabilitiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSurfaceProtectedCapabilitiesKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSurfaceProtectedCapabilitiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDepthClipEnableFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDepthClipEnableFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRasterizationDepthClipStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRasterizationDepthClipStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMemoryBudgetPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMemoryBudgetPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMemoryPriorityFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMemoryPriorityFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryPriorityAllocateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryPriorityAllocateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryPriorityAllocateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceBufferDeviceAddressFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceBufferDeviceAddressFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferDeviceAddressInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferDeviceAddressInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferDeviceAddressInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferOpaqueCaptureAddressCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferOpaqueCaptureAddressCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferOpaqueCaptureAddressCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferDeviceAddressCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferDeviceAddressCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferDeviceAddressCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImageViewImageFormatInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImageViewImageFormatInfoEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFilterCubicImageViewImageFormatPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFilterCubicImageViewImageFormatPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImagelessFramebufferFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImagelessFramebufferFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFramebufferAttachmentsCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFramebufferAttachmentsCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFramebufferAttachmentsCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFramebufferAttachmentImageInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFramebufferAttachmentImageInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFramebufferAttachmentImageInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassAttachmentBeginInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassAttachmentBeginInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassAttachmentBeginInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceTextureCompressionASTCHDRFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceCooperativeMatrixFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceCooperativeMatrixFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceCooperativeMatrixPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceCooperativeMatrixPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCooperativeMatrixPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCooperativeMatrixPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCooperativeMatrixPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageViewHandleInfoNVX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageViewHandleInfoNVX>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageViewHandleInfoNVX));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageViewAddressPropertiesNVX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageViewAddressPropertiesNVX>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageViewAddressPropertiesNVX));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineCreationFeedbackCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineCreationFeedbackCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineCreationFeedbackCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePerformanceQueryFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePerformanceQueryFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePerformanceQueryPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePerformanceQueryPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPerformanceCounterKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPerformanceCounterKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPerformanceCounterKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPerformanceCounterDescriptionKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPerformanceCounterDescriptionKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPerformanceCounterDescriptionKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueryPoolPerformanceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueryPoolPerformanceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueryPoolPerformanceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAcquireProfilingLockInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAcquireProfilingLockInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAcquireProfilingLockInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPerformanceQuerySubmitInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPerformanceQuerySubmitInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPerformanceQuerySubmitInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkHeadlessSurfaceCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkHeadlessSurfaceCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkHeadlessSurfaceCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceCoverageReductionModeFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceCoverageReductionModeFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineCoverageReductionStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineCoverageReductionStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineCoverageReductionStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFramebufferMixedSamplesCombinationNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFramebufferMixedSamplesCombinationNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFramebufferMixedSamplesCombinationNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkInitializePerformanceApiInfoINTEL& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkInitializePerformanceApiInfoINTEL>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkInitializePerformanceApiInfoINTEL));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueryPoolPerformanceQueryCreateInfoINTEL& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueryPoolPerformanceQueryCreateInfoINTEL>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueryPoolPerformanceQueryCreateInfoINTEL));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPerformanceMarkerInfoINTEL& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPerformanceMarkerInfoINTEL>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPerformanceMarkerInfoINTEL));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPerformanceStreamMarkerInfoINTEL& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPerformanceStreamMarkerInfoINTEL>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPerformanceStreamMarkerInfoINTEL));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPerformanceOverrideInfoINTEL& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPerformanceOverrideInfoINTEL>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPerformanceOverrideInfoINTEL));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPerformanceConfigurationAcquireInfoINTEL& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPerformanceConfigurationAcquireInfoINTEL>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPerformanceConfigurationAcquireInfoINTEL));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderClockFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderClockFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAttachmentReferenceStencilLayout& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAttachmentReferenceStencilLayout>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAttachmentReferenceStencilLayout));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAttachmentDescriptionStencilLayout& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAttachmentDescriptionStencilLayout>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAttachmentDescriptionStencilLayout));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineExecutablePropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineExecutablePropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutablePropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineExecutableInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineExecutableInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutableInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineExecutableStatisticKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineExecutableStatisticKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutableStatisticKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineExecutableInternalRepresentationKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineExecutableInternalRepresentationKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutableInternalRepresentationKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceTexelBufferAlignmentProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceTexelBufferAlignmentProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSubgroupSizeControlFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSubgroupSizeControlFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSubgroupSizeControlProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSubgroupSizeControlProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubgroupSizeControlProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassShadingPipelineCreateInfoHUAWEI& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassShadingPipelineCreateInfoHUAWEI>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassShadingPipelineCreateInfoHUAWEI));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryOpaqueCaptureAddressAllocateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryOpaqueCaptureAddressAllocateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceMemoryOpaqueCaptureAddressInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceMemoryOpaqueCaptureAddressInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceMemoryOpaqueCaptureAddressInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceLineRasterizationFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceLineRasterizationPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceLineRasterizationPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRasterizationLineStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRasterizationLineStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationLineStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePipelineCreationCacheControlFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePipelineCreationCacheControlFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVulkan11Features& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVulkan11Features>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan11Features));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVulkan11Properties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVulkan11Properties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan11Properties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVulkan12Features& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVulkan12Features>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan12Features));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVulkan12Properties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVulkan12Properties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan12Properties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVulkan13Features& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVulkan13Features>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan13Features));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVulkan13Properties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVulkan13Properties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan13Properties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineCompilerControlCreateInfoAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineCompilerControlCreateInfoAMD>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineCompilerControlCreateInfoAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceCoherentMemoryFeaturesAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceCoherentMemoryFeaturesAMD>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceToolProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceToolProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceToolProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSamplerCustomBorderColorCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSamplerCustomBorderColorCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSamplerCustomBorderColorCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceCustomBorderColorPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceCustomBorderColorPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceCustomBorderColorFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceCustomBorderColorFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSamplerBorderColorComponentMappingCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSamplerBorderColorComponentMappingCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSamplerBorderColorComponentMappingCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureGeometryTrianglesDataKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureGeometryTrianglesDataKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryTrianglesDataKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureGeometryAabbsDataKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureGeometryAabbsDataKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryAabbsDataKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureGeometryInstancesDataKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureGeometryInstancesDataKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryInstancesDataKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureGeometryKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureGeometryKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureBuildGeometryInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureBuildGeometryInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureBuildGeometryInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureDeviceAddressInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureDeviceAddressInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureDeviceAddressInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureVersionInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureVersionInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureVersionInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyAccelerationStructureInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyAccelerationStructureInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyAccelerationStructureInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyAccelerationStructureToMemoryInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyAccelerationStructureToMemoryInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyAccelerationStructureToMemoryInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyMemoryToAccelerationStructureInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyMemoryToAccelerationStructureInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyMemoryToAccelerationStructureInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRayTracingPipelineInterfaceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRayTracingPipelineInterfaceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRayTracingPipelineInterfaceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineLibraryCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineLibraryCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineLibraryCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassTransformBeginInfoQCOM& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassTransformBeginInfoQCOM>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassTransformBeginInfoQCOM));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyCommandTransformInfoQCOM& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyCommandTransformInfoQCOM>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyCommandTransformInfoQCOM));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferInheritanceRenderPassTransformInfoQCOM>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDiagnosticsConfigFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDeviceDiagnosticsConfigCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDeviceDiagnosticsConfigCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDeviceDiagnosticsConfigCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRobustness2FeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRobustness2FeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRobustness2FeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRobustness2PropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRobustness2PropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRobustness2PropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImageRobustnessFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImageRobustnessFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageRobustnessFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevice4444FormatsFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevice4444FormatsFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevice4444FormatsFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferCopy2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferCopy2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferCopy2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageCopy2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageCopy2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageCopy2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageBlit2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageBlit2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageBlit2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferImageCopy2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferImageCopy2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferImageCopy2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageResolve2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageResolve2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageResolve2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyBufferInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyBufferInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyBufferInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyImageInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyImageInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyImageInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBlitImageInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBlitImageInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBlitImageInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyBufferToImageInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyBufferToImageInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyBufferToImageInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCopyImageToBufferInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCopyImageToBufferInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCopyImageToBufferInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkResolveImageInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkResolveImageInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkResolveImageInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFragmentShadingRateAttachmentInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFragmentShadingRateAttachmentInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFragmentShadingRateAttachmentInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineFragmentShadingRateStateCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineFragmentShadingRateStateCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShadingRateKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderTerminateInvocationFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderTerminateInvocationFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineFragmentShadingRateEnumStateCreateInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureBuildSizesInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureBuildSizesInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureBuildSizesInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMutableDescriptorTypeCreateInfoVALVE& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMutableDescriptorTypeCreateInfoVALVE>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMutableDescriptorTypeCreateInfoVALVE));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDepthClipControlFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDepthClipControlFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineViewportDepthClipControlCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineViewportDepthClipControlCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVertexInputBindingDescription2EXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVertexInputBindingDescription2EXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVertexInputBindingDescription2EXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVertexInputAttributeDescription2EXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVertexInputAttributeDescription2EXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVertexInputAttributeDescription2EXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceColorWriteEnableFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceColorWriteEnableFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineColorWriteCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineColorWriteCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineColorWriteCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryBarrier2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryBarrier2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryBarrier2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageMemoryBarrier2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageMemoryBarrier2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageMemoryBarrier2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferMemoryBarrier2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferMemoryBarrier2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferMemoryBarrier2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDependencyInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDependencyInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDependencyInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreSubmitInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreSubmitInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreSubmitInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferSubmitInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferSubmitInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferSubmitInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubmitInfo2& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubmitInfo2>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubmitInfo2));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueueFamilyCheckpointProperties2NV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueueFamilyCheckpointProperties2NV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyCheckpointProperties2NV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCheckpointData2NV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCheckpointData2NV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCheckpointData2NV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSynchronization2Features& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSynchronization2Features>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSynchronization2Features));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubpassResolvePerformanceQueryEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubpassResolvePerformanceQueryEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubpassResolvePerformanceQueryEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMultisampledRenderToSingleSampledInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMultisampledRenderToSingleSampledInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMultisampledRenderToSingleSampledInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceInheritedViewportScissorFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferInheritanceViewportScissorInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferInheritanceViewportScissorInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceViewportScissorInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceProvokingVertexFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceProvokingVertexFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceProvokingVertexPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceProvokingVertexPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProvokingVertexPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCuModuleCreateInfoNVX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCuModuleCreateInfoNVX>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCuModuleCreateInfoNVX));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCuFunctionCreateInfoNVX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCuFunctionCreateInfoNVX>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCuFunctionCreateInfoNVX));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCuLaunchInfoNVX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCuLaunchInfoNVX>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCuLaunchInfoNVX));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderIntegerDotProductFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderIntegerDotProductFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderIntegerDotProductProperties& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderIntegerDotProductProperties>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderIntegerDotProductProperties));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDrmPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDrmPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDrmPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureGeometryMotionTrianglesDataNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureGeometryMotionTrianglesDataNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryMotionTrianglesDataNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAccelerationStructureMotionInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAccelerationStructureMotionInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureMotionInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryGetRemoteAddressInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryGetRemoteAddressInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryGetRemoteAddressInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFormatProperties3& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFormatProperties3>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFormatProperties3));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDrmFormatModifierPropertiesList2EXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDrmFormatModifierPropertiesList2EXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDrmFormatModifierPropertiesList2EXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRenderingCreateInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRenderingCreateInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRenderingCreateInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderingInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderingInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderingInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderingAttachmentInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderingAttachmentInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderingAttachmentInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderingFragmentShadingRateAttachmentInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderingFragmentShadingRateAttachmentInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderingFragmentDensityMapAttachmentInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderingFragmentDensityMapAttachmentInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDynamicRenderingFeatures& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDynamicRenderingFeatures>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDynamicRenderingFeatures));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkCommandBufferInheritanceRenderingInfo& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkCommandBufferInheritanceRenderingInfo>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceRenderingInfo));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAttachmentSampleCountInfoAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAttachmentSampleCountInfoAMD>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAttachmentSampleCountInfoAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMultiviewPerViewAttributesInfoNVX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMultiviewPerViewAttributesInfoNVX>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMultiviewPerViewAttributesInfoNVX));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImageViewMinLodFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImageViewMinLodFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageViewMinLodCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageViewMinLodCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageViewMinLodCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkGraphicsPipelineLibraryCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkGraphicsPipelineLibraryCreateInfoEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkGraphicsPipelineLibraryCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetBindingReferenceVALVE& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetBindingReferenceVALVE>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetBindingReferenceVALVE));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkDescriptorSetLayoutHostMappingInfoVALVE& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDescriptorSetLayoutHostMappingInfoVALVE>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutHostMappingInfoVALVE));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkShaderModuleIdentifierEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkShaderModuleIdentifierEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkShaderModuleIdentifierEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageCompressionControlEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageCompressionControlEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageCompressionControlEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImageCompressionControlFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImageCompressionControlFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageCompressionPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageCompressionPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageCompressionPropertiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageSubresource2EXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageSubresource2EXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageSubresource2EXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSubresourceLayout2EXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSubresourceLayout2EXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSubresourceLayout2EXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassCreationControlEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassCreationControlEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreationControlEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassCreationFeedbackCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassCreationFeedbackCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreationFeedbackCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkRenderPassSubpassFeedbackCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkRenderPassSubpassFeedbackCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkRenderPassSubpassFeedbackCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelinePropertiesIdentifierEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelinePropertiesIdentifierEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelinePropertiesIdentifierEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePipelinePropertiesFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePipelinePropertiesFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePipelineRobustnessFeaturesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePipelineRobustnessFeaturesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineRobustnessFeaturesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPipelineRobustnessCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPipelineRobustnessCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPipelineRobustnessCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePipelineRobustnessPropertiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePipelineRobustnessPropertiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineRobustnessPropertiesEXT));
    copyIndirectData(*valueCopy);
}

#if defined(VK_USE_PLATFORM_ANDROID_KHR)

inline void variantWrap(const VkAndroidSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAndroidSurfaceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAndroidSurfaceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkNativeBufferANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkNativeBufferANDROID>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkNativeBufferANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSwapchainImageCreateInfoANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSwapchainImageCreateInfoANDROID>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSwapchainImageCreateInfoANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePresentationPropertiesANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePresentationPropertiesANDROID>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePresentationPropertiesANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportAndroidHardwareBufferInfoANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportAndroidHardwareBufferInfoANDROID>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportAndroidHardwareBufferInfoANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAndroidHardwareBufferUsageANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAndroidHardwareBufferUsageANDROID>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAndroidHardwareBufferUsageANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAndroidHardwareBufferPropertiesANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAndroidHardwareBufferPropertiesANDROID>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAndroidHardwareBufferPropertiesANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryGetAndroidHardwareBufferInfoANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryGetAndroidHardwareBufferInfoANDROID>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryGetAndroidHardwareBufferInfoANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkAndroidHardwareBufferFormatPropertiesANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkAndroidHardwareBufferFormatPropertiesANDROID>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExternalFormatANDROID& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExternalFormatANDROID>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExternalFormatANDROID));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_ANDROID_KHR)

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

inline void variantWrap(const VkDirectFBSurfaceCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkDirectFBSurfaceCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkDirectFBSurfaceCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#if defined(VK_USE_PLATFORM_FUCHSIA)

inline void variantWrap(VkBufferCollectionFUCHSIA value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA;
    outVariant.objectValue.value = value;
}

inline void variantWrap(const VkImagePipeSurfaceCreateInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImagePipeSurfaceCreateInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImagePipeSurfaceCreateInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMemoryZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMemoryZirconHandleInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMemoryZirconHandleInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryZirconHandlePropertiesFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryZirconHandlePropertiesFUCHSIA>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryZirconHandlePropertiesFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryGetZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryGetZirconHandleInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryGetZirconHandleInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportSemaphoreZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportSemaphoreZirconHandleInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportSemaphoreZirconHandleInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreGetZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreGetZirconHandleInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreGetZirconHandleInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMemoryBufferCollectionFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMemoryBufferCollectionFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMemoryBufferCollectionFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferCollectionImageCreateInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferCollectionImageCreateInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionImageCreateInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferCollectionBufferCreateInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferCollectionBufferCreateInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionBufferCreateInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferCollectionCreateInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferCollectionCreateInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionCreateInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferCollectionPropertiesFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferCollectionPropertiesFUCHSIA>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionPropertiesFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferConstraintsInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferConstraintsInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSysmemColorSpaceFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSysmemColorSpaceFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSysmemColorSpaceFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageFormatConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageFormatConstraintsInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageFormatConstraintsInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImageConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImageConstraintsInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImageConstraintsInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBufferCollectionConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBufferCollectionConstraintsInfoFUCHSIA>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionConstraintsInfoFUCHSIA));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_FUCHSIA)

#if defined(VK_USE_PLATFORM_GGP)

inline void variantWrap(const VkStreamDescriptorSurfaceCreateInfoGGP& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkStreamDescriptorSurfaceCreateInfoGGP>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkStreamDescriptorSurfaceCreateInfoGGP));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPresentFrameTokenGGP& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPresentFrameTokenGGP>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPresentFrameTokenGGP));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_GGP)

#if defined(VK_USE_PLATFORM_IOS_MVK)

inline void variantWrap(const VkIOSSurfaceCreateInfoMVK& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkIOSSurfaceCreateInfoMVK>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkIOSSurfaceCreateInfoMVK));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_IOS_MVK)

#if defined(VK_USE_PLATFORM_MACOS_MVK)

inline void variantWrap(const VkMacOSSurfaceCreateInfoMVK& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMacOSSurfaceCreateInfoMVK>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMacOSSurfaceCreateInfoMVK));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_MACOS_MVK)

#if defined(VK_USE_PLATFORM_METAL_EXT)

inline void variantWrap(const VkMetalSurfaceCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMetalSurfaceCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMetalSurfaceCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalObjectCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalObjectCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalObjectCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalObjectsInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalObjectsInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalObjectsInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalDeviceInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalDeviceInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalDeviceInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalCommandQueueInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalCommandQueueInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalCommandQueueInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalBufferInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalBufferInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalBufferInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMetalBufferInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMetalBufferInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMetalBufferInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalTextureInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalTextureInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalTextureInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMetalTextureInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMetalTextureInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMetalTextureInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalIOSurfaceInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalIOSurfaceInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalIOSurfaceInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMetalIOSurfaceInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMetalIOSurfaceInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMetalIOSurfaceInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMetalSharedEventInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMetalSharedEventInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMetalSharedEventInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMetalSharedEventInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMetalSharedEventInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMetalSharedEventInfoEXT));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_METAL_EXT)

#if defined(VK_ENABLE_BETA_EXTENSIONS)

inline void variantWrap(VkVideoSessionKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_VIDEO_SESSION_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(VkVideoSessionParametersKHR value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN;
    outVariant.objectValue.type = VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR;
    outVariant.objectValue.value = value;
}

inline void variantWrap(const VkPhysicalDevicePortabilitySubsetFeaturesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePortabilitySubsetFeaturesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDevicePortabilitySubsetPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDevicePortabilitySubsetPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueueFamilyVideoPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueueFamilyVideoPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyVideoPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkQueueFamilyQueryResultStatusPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkQueueFamilyQueryResultStatusPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyQueryResultStatusPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoProfileListInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoProfileListInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoProfileListInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkPhysicalDeviceVideoFormatInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkPhysicalDeviceVideoFormatInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVideoFormatInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoFormatPropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoFormatPropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoFormatPropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoProfileInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoProfileInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoProfileInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoCapabilitiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoCapabilitiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoCapabilitiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoSessionMemoryRequirementsKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoSessionMemoryRequirementsKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoSessionMemoryRequirementsKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkBindVideoSessionMemoryInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkBindVideoSessionMemoryInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkBindVideoSessionMemoryInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoPictureResourceInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoPictureResourceInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoPictureResourceInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoReferenceSlotInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoReferenceSlotInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoReferenceSlotInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeCapabilitiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeCapabilitiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeCapabilitiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeUsageInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeUsageInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeUsageInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH264ProfileInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH264ProfileInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264ProfileInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH264CapabilitiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH264CapabilitiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264CapabilitiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH264SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH264SessionParametersAddInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH264SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH264SessionParametersCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH264PictureInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH264PictureInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264PictureInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH264DpbSlotInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH264DpbSlotInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264DpbSlotInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH264MvcInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH264MvcInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264MvcInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH265ProfileInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH265ProfileInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265ProfileInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH265CapabilitiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH265CapabilitiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265CapabilitiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH265SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH265SessionParametersAddInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH265SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH265SessionParametersCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH265PictureInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH265PictureInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265PictureInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoDecodeH265DpbSlotInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoDecodeH265DpbSlotInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265DpbSlotInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoSessionCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoSessionCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoSessionCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoSessionParametersCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoSessionParametersCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoSessionParametersCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoSessionParametersUpdateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoSessionParametersUpdateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoSessionParametersUpdateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoBeginCodingInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoBeginCodingInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoBeginCodingInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEndCodingInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEndCodingInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEndCodingInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoCodingControlInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoCodingControlInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoCodingControlInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeUsageInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeUsageInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeUsageInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeRateControlInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeRateControlInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeRateControlInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeRateControlLayerInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeRateControlLayerInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeRateControlLayerInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeCapabilitiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeCapabilitiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeCapabilitiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264CapabilitiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264CapabilitiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264CapabilitiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264SessionParametersAddInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264SessionParametersCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264DpbSlotInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264DpbSlotInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264DpbSlotInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264VclFrameInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264VclFrameInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264VclFrameInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264ReferenceListsInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264ReferenceListsInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264ReferenceListsInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264EmitPictureParametersInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264EmitPictureParametersInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264EmitPictureParametersInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264ProfileInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264ProfileInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264ProfileInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264NaluSliceInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264NaluSliceInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264NaluSliceInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264RateControlInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264RateControlInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264RateControlInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH264RateControlLayerInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH264RateControlLayerInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264RateControlLayerInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265CapabilitiesEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265CapabilitiesEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265CapabilitiesEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265SessionParametersAddInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265SessionParametersCreateInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265VclFrameInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265VclFrameInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265VclFrameInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265EmitPictureParametersInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265EmitPictureParametersInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265EmitPictureParametersInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265NaluSliceSegmentInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265NaluSliceSegmentInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265NaluSliceSegmentInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265RateControlInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265RateControlInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265RateControlInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265RateControlLayerInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265RateControlLayerInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265RateControlLayerInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265ProfileInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265ProfileInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265ProfileInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265DpbSlotInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265DpbSlotInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265DpbSlotInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkVideoEncodeH265ReferenceListsInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkVideoEncodeH265ReferenceListsInfoEXT>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265ReferenceListsInfoEXT));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_ENABLE_BETA_EXTENSIONS)

#if defined(VK_USE_PLATFORM_SCREEN_QNX)

inline void variantWrap(const VkScreenSurfaceCreateInfoQNX& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkScreenSurfaceCreateInfoQNX>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkScreenSurfaceCreateInfoQNX));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_SCREEN_QNX)

#if defined(VK_USE_PLATFORM_VI_NN)

inline void variantWrap(const VkViSurfaceCreateInfoNN& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkViSurfaceCreateInfoNN>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkViSurfaceCreateInfoNN));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_VI_NN)

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

inline void variantWrap(const VkWaylandSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWaylandSurfaceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWaylandSurfaceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR)

#if defined(VK_USE_PLATFORM_WIN32_KHR)

inline void variantWrap(const VkWin32SurfaceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWin32SurfaceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWin32SurfaceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMemoryWin32HandleInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMemoryWin32HandleInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMemoryWin32HandleInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMemoryWin32HandleInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMemoryWin32HandleInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMemoryWin32HandleInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkWin32KeyedMutexAcquireReleaseInfoNV& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWin32KeyedMutexAcquireReleaseInfoNV>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportMemoryWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportMemoryWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportMemoryWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportMemoryWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportMemoryWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportMemoryWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryWin32HandlePropertiesKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryWin32HandlePropertiesKHR>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryWin32HandlePropertiesKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkMemoryGetWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkMemoryGetWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkMemoryGetWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkWin32KeyedMutexAcquireReleaseInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkWin32KeyedMutexAcquireReleaseInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportSemaphoreWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportSemaphoreWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportSemaphoreWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportSemaphoreWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportSemaphoreWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportSemaphoreWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkD3D12FenceSubmitInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkD3D12FenceSubmitInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkD3D12FenceSubmitInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSemaphoreGetWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSemaphoreGetWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSemaphoreGetWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkImportFenceWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkImportFenceWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkImportFenceWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkExportFenceWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkExportFenceWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkExportFenceWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkFenceGetWin32HandleInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkFenceGetWin32HandleInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkFenceGetWin32HandleInfoKHR));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSurfaceFullScreenExclusiveInfoEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSurfaceFullScreenExclusiveInfoEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSurfaceFullScreenExclusiveInfoEXT));
    copyIndirectData(*valueCopy);
}

inline void variantWrap(const VkSurfaceCapabilitiesFullScreenExclusiveEXT& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN;

    auto valueCopy = allocType<VkSurfaceCapabilitiesFullScreenExclusiveEXT>();
    outVariant.outStructureValue = reinterpret_cast<VkBaseOutStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_WIN32_KHR)

#if defined(VK_USE_PLATFORM_XCB_KHR)

inline void variantWrap(const VkXcbSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkXcbSurfaceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkXcbSurfaceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_XCB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_KHR)

inline void variantWrap(const VkXlibSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant)
{
    outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN;

    auto valueCopy = allocType<VkXlibSurfaceCreateInfoKHR>();
    outVariant.inStructureValue = reinterpret_cast<VkBaseInStructure*>(valueCopy);

    std::memcpy(valueCopy, &value, sizeof(VkXlibSurfaceCreateInfoKHR));
    copyIndirectData(*valueCopy);
}

#endif // defined(VK_USE_PLATFORM_XLIB_KHR)

inline void* copyNextPtr(const void* pNext)
{
    if (pNext == nullptr) {
        return nullptr;
    }
    const VkStructureType sType = *static_cast<const VkStructureType*>(pNext);
    void* pCopy = nullptr;
    switch (sType)
    {
        case VK_STRUCTURE_TYPE_APPLICATION_INFO:
            pCopy = allocType<VkApplicationInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkApplicationInfo));
            copyIndirectData(*static_cast<VkApplicationInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
            pCopy = allocType<VkDeviceQueueCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceQueueCreateInfo));
            copyIndirectData(*static_cast<VkDeviceQueueCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
            pCopy = allocType<VkDeviceCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceCreateInfo));
            copyIndirectData(*static_cast<VkDeviceCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
            pCopy = allocType<VkInstanceCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkInstanceCreateInfo));
            copyIndirectData(*static_cast<VkInstanceCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
            pCopy = allocType<VkMemoryAllocateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryAllocateInfo));
            copyIndirectData(*static_cast<VkMemoryAllocateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
            pCopy = allocType<VkMappedMemoryRange>();
            std::memcpy(pCopy, pNext, sizeof(VkMappedMemoryRange));
            copyIndirectData(*static_cast<VkMappedMemoryRange*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
            pCopy = allocType<VkWriteDescriptorSet>();
            std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSet));
            copyIndirectData(*static_cast<VkWriteDescriptorSet*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
            pCopy = allocType<VkCopyDescriptorSet>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyDescriptorSet));
            copyIndirectData(*static_cast<VkCopyDescriptorSet*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
            pCopy = allocType<VkBufferCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferCreateInfo));
            copyIndirectData(*static_cast<VkBufferCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
            pCopy = allocType<VkBufferViewCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferViewCreateInfo));
            copyIndirectData(*static_cast<VkBufferViewCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
            pCopy = allocType<VkMemoryBarrier>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryBarrier));
            copyIndirectData(*static_cast<VkMemoryBarrier*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
            pCopy = allocType<VkBufferMemoryBarrier>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferMemoryBarrier));
            copyIndirectData(*static_cast<VkBufferMemoryBarrier*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
            pCopy = allocType<VkImageMemoryBarrier>();
            std::memcpy(pCopy, pNext, sizeof(VkImageMemoryBarrier));
            copyIndirectData(*static_cast<VkImageMemoryBarrier*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
            pCopy = allocType<VkImageCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkImageCreateInfo));
            copyIndirectData(*static_cast<VkImageCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
            pCopy = allocType<VkImageViewCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkImageViewCreateInfo));
            copyIndirectData(*static_cast<VkImageViewCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
            pCopy = allocType<VkBindSparseInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBindSparseInfo));
            copyIndirectData(*static_cast<VkBindSparseInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
            pCopy = allocType<VkShaderModuleCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkShaderModuleCreateInfo));
            copyIndirectData(*static_cast<VkShaderModuleCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
            pCopy = allocType<VkDescriptorSetLayoutCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutCreateInfo));
            copyIndirectData(*static_cast<VkDescriptorSetLayoutCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
            pCopy = allocType<VkDescriptorPoolCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorPoolCreateInfo));
            copyIndirectData(*static_cast<VkDescriptorPoolCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
            pCopy = allocType<VkDescriptorSetAllocateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetAllocateInfo));
            copyIndirectData(*static_cast<VkDescriptorSetAllocateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
            pCopy = allocType<VkPipelineShaderStageCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineShaderStageCreateInfo));
            copyIndirectData(*static_cast<VkPipelineShaderStageCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
            pCopy = allocType<VkComputePipelineCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkComputePipelineCreateInfo));
            copyIndirectData(*static_cast<VkComputePipelineCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineVertexInputStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineVertexInputStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineVertexInputStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineInputAssemblyStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineInputAssemblyStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineInputAssemblyStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineTessellationStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineTessellationStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineTessellationStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineViewportStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineViewportStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineRasterizationStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineRasterizationStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineMultisampleStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineMultisampleStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineMultisampleStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineColorBlendStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineColorBlendStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineColorBlendStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineDynamicStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineDynamicStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineDynamicStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineDepthStencilStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineDepthStencilStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineDepthStencilStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
            pCopy = allocType<VkGraphicsPipelineCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkGraphicsPipelineCreateInfo));
            copyIndirectData(*static_cast<VkGraphicsPipelineCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
            pCopy = allocType<VkPipelineCacheCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineCacheCreateInfo));
            copyIndirectData(*static_cast<VkPipelineCacheCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
            pCopy = allocType<VkPipelineLayoutCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineLayoutCreateInfo));
            copyIndirectData(*static_cast<VkPipelineLayoutCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
            pCopy = allocType<VkSamplerCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSamplerCreateInfo));
            copyIndirectData(*static_cast<VkSamplerCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
            pCopy = allocType<VkCommandPoolCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandPoolCreateInfo));
            copyIndirectData(*static_cast<VkCommandPoolCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
            pCopy = allocType<VkCommandBufferAllocateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferAllocateInfo));
            copyIndirectData(*static_cast<VkCommandBufferAllocateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
            pCopy = allocType<VkCommandBufferInheritanceInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceInfo));
            copyIndirectData(*static_cast<VkCommandBufferInheritanceInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
            pCopy = allocType<VkCommandBufferBeginInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferBeginInfo));
            copyIndirectData(*static_cast<VkCommandBufferBeginInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
            pCopy = allocType<VkRenderPassBeginInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassBeginInfo));
            copyIndirectData(*static_cast<VkRenderPassBeginInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
            pCopy = allocType<VkRenderPassCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreateInfo));
            copyIndirectData(*static_cast<VkRenderPassCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
            pCopy = allocType<VkEventCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkEventCreateInfo));
            copyIndirectData(*static_cast<VkEventCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
            pCopy = allocType<VkFenceCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkFenceCreateInfo));
            copyIndirectData(*static_cast<VkFenceCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
            pCopy = allocType<VkSemaphoreCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreCreateInfo));
            copyIndirectData(*static_cast<VkSemaphoreCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
            pCopy = allocType<VkQueryPoolCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkQueryPoolCreateInfo));
            copyIndirectData(*static_cast<VkQueryPoolCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
            pCopy = allocType<VkFramebufferCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkFramebufferCreateInfo));
            copyIndirectData(*static_cast<VkFramebufferCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBMIT_INFO:
            pCopy = allocType<VkSubmitInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSubmitInfo));
            copyIndirectData(*static_cast<VkSubmitInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
            pCopy = allocType<VkDisplayModeCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayModeCreateInfoKHR));
            copyIndirectData(*static_cast<VkDisplayModeCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
            pCopy = allocType<VkDisplaySurfaceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplaySurfaceCreateInfoKHR));
            copyIndirectData(*static_cast<VkDisplaySurfaceCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
            pCopy = allocType<VkDisplayPresentInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayPresentInfoKHR));
            copyIndirectData(*static_cast<VkDisplayPresentInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
            pCopy = allocType<VkSwapchainCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkSwapchainCreateInfoKHR));
            copyIndirectData(*static_cast<VkSwapchainCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
            pCopy = allocType<VkPresentInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPresentInfoKHR));
            copyIndirectData(*static_cast<VkPresentInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
            pCopy = allocType<VkDebugReportCallbackCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugReportCallbackCreateInfoEXT));
            copyIndirectData(*static_cast<VkDebugReportCallbackCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
            pCopy = allocType<VkValidationFlagsEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkValidationFlagsEXT));
            copyIndirectData(*static_cast<VkValidationFlagsEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
            pCopy = allocType<VkValidationFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkValidationFeaturesEXT));
            copyIndirectData(*static_cast<VkValidationFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
            pCopy = allocType<VkPipelineRasterizationStateRasterizationOrderAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationStateRasterizationOrderAMD));
            copyIndirectData(*static_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
            pCopy = allocType<VkDebugMarkerObjectNameInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugMarkerObjectNameInfoEXT));
            copyIndirectData(*static_cast<VkDebugMarkerObjectNameInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
            pCopy = allocType<VkDebugMarkerObjectTagInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugMarkerObjectTagInfoEXT));
            copyIndirectData(*static_cast<VkDebugMarkerObjectTagInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
            pCopy = allocType<VkDebugMarkerMarkerInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugMarkerMarkerInfoEXT));
            copyIndirectData(*static_cast<VkDebugMarkerMarkerInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
            pCopy = allocType<VkDedicatedAllocationImageCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkDedicatedAllocationImageCreateInfoNV));
            copyIndirectData(*static_cast<VkDedicatedAllocationImageCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
            pCopy = allocType<VkDedicatedAllocationBufferCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkDedicatedAllocationBufferCreateInfoNV));
            copyIndirectData(*static_cast<VkDedicatedAllocationBufferCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
            pCopy = allocType<VkDedicatedAllocationMemoryAllocateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkDedicatedAllocationMemoryAllocateInfoNV));
            copyIndirectData(*static_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
            pCopy = allocType<VkExternalMemoryImageCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalMemoryImageCreateInfoNV));
            copyIndirectData(*static_cast<VkExternalMemoryImageCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
            pCopy = allocType<VkExportMemoryAllocateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMemoryAllocateInfoNV));
            copyIndirectData(*static_cast<VkExportMemoryAllocateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
            pCopy = allocType<VkDevicePrivateDataCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDevicePrivateDataCreateInfo));
            copyIndirectData(*static_cast<VkDevicePrivateDataCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
            pCopy = allocType<VkPrivateDataSlotCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPrivateDataSlotCreateInfo));
            copyIndirectData(*static_cast<VkPrivateDataSlotCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
            pCopy = allocType<VkPhysicalDevicePrivateDataFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePrivateDataFeatures));
            copyIndirectData(*static_cast<VkPhysicalDevicePrivateDataFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
            pCopy = allocType<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceMultiDrawPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
            pCopy = allocType<VkGraphicsShaderGroupCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkGraphicsShaderGroupCreateInfoNV));
            copyIndirectData(*static_cast<VkGraphicsShaderGroupCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
            pCopy = allocType<VkGraphicsPipelineShaderGroupsCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkGraphicsPipelineShaderGroupsCreateInfoNV));
            copyIndirectData(*static_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
            pCopy = allocType<VkIndirectCommandsLayoutTokenNV>();
            std::memcpy(pCopy, pNext, sizeof(VkIndirectCommandsLayoutTokenNV));
            copyIndirectData(*static_cast<VkIndirectCommandsLayoutTokenNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
            pCopy = allocType<VkIndirectCommandsLayoutCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkIndirectCommandsLayoutCreateInfoNV));
            copyIndirectData(*static_cast<VkIndirectCommandsLayoutCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
            pCopy = allocType<VkGeneratedCommandsInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkGeneratedCommandsInfoNV));
            copyIndirectData(*static_cast<VkGeneratedCommandsInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
            pCopy = allocType<VkGeneratedCommandsMemoryRequirementsInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkGeneratedCommandsMemoryRequirementsInfoNV));
            copyIndirectData(*static_cast<VkGeneratedCommandsMemoryRequirementsInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
            pCopy = allocType<VkPhysicalDeviceFeatures2>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFeatures2));
            copyIndirectData(*static_cast<VkPhysicalDeviceFeatures2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
            pCopy = allocType<VkPhysicalDeviceProperties2>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProperties2));
            copyIndirectData(*static_cast<VkPhysicalDeviceProperties2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
            pCopy = allocType<VkFormatProperties2>();
            std::memcpy(pCopy, pNext, sizeof(VkFormatProperties2));
            copyIndirectData(*static_cast<VkFormatProperties2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
            pCopy = allocType<VkImageFormatProperties2>();
            std::memcpy(pCopy, pNext, sizeof(VkImageFormatProperties2));
            copyIndirectData(*static_cast<VkImageFormatProperties2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
            pCopy = allocType<VkPhysicalDeviceImageFormatInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageFormatInfo2));
            copyIndirectData(*static_cast<VkPhysicalDeviceImageFormatInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
            pCopy = allocType<VkQueueFamilyProperties2>();
            std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyProperties2));
            copyIndirectData(*static_cast<VkQueueFamilyProperties2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
            pCopy = allocType<VkPhysicalDeviceMemoryProperties2>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMemoryProperties2));
            copyIndirectData(*static_cast<VkPhysicalDeviceMemoryProperties2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
            pCopy = allocType<VkSparseImageFormatProperties2>();
            std::memcpy(pCopy, pNext, sizeof(VkSparseImageFormatProperties2));
            copyIndirectData(*static_cast<VkSparseImageFormatProperties2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
            pCopy = allocType<VkPhysicalDeviceSparseImageFormatInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSparseImageFormatInfo2));
            copyIndirectData(*static_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
            pCopy = allocType<VkPhysicalDevicePushDescriptorPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceDriverProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDriverProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceDriverProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
            pCopy = allocType<VkPresentRegionsKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPresentRegionsKHR));
            copyIndirectData(*static_cast<VkPresentRegionsKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
            pCopy = allocType<VkPhysicalDeviceVariablePointersFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVariablePointersFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceVariablePointersFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
            pCopy = allocType<VkPhysicalDeviceExternalImageFormatInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalImageFormatInfo));
            copyIndirectData(*static_cast<VkPhysicalDeviceExternalImageFormatInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
            pCopy = allocType<VkExternalImageFormatProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalImageFormatProperties));
            copyIndirectData(*static_cast<VkExternalImageFormatProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
            pCopy = allocType<VkPhysicalDeviceExternalBufferInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalBufferInfo));
            copyIndirectData(*static_cast<VkPhysicalDeviceExternalBufferInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
            pCopy = allocType<VkExternalBufferProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalBufferProperties));
            copyIndirectData(*static_cast<VkExternalBufferProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceIDProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceIDProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceIDProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
            pCopy = allocType<VkExternalMemoryImageCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalMemoryImageCreateInfo));
            copyIndirectData(*static_cast<VkExternalMemoryImageCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
            pCopy = allocType<VkExternalMemoryBufferCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalMemoryBufferCreateInfo));
            copyIndirectData(*static_cast<VkExternalMemoryBufferCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
            pCopy = allocType<VkExportMemoryAllocateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMemoryAllocateInfo));
            copyIndirectData(*static_cast<VkExportMemoryAllocateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
            pCopy = allocType<VkImportMemoryFdInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMemoryFdInfoKHR));
            copyIndirectData(*static_cast<VkImportMemoryFdInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
            pCopy = allocType<VkMemoryFdPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryFdPropertiesKHR));
            copyIndirectData(*static_cast<VkMemoryFdPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
            pCopy = allocType<VkMemoryGetFdInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryGetFdInfoKHR));
            copyIndirectData(*static_cast<VkMemoryGetFdInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
            pCopy = allocType<VkPhysicalDeviceExternalSemaphoreInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalSemaphoreInfo));
            copyIndirectData(*static_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
            pCopy = allocType<VkExternalSemaphoreProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalSemaphoreProperties));
            copyIndirectData(*static_cast<VkExternalSemaphoreProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
            pCopy = allocType<VkExportSemaphoreCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkExportSemaphoreCreateInfo));
            copyIndirectData(*static_cast<VkExportSemaphoreCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
            pCopy = allocType<VkImportSemaphoreFdInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkImportSemaphoreFdInfoKHR));
            copyIndirectData(*static_cast<VkImportSemaphoreFdInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
            pCopy = allocType<VkSemaphoreGetFdInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreGetFdInfoKHR));
            copyIndirectData(*static_cast<VkSemaphoreGetFdInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
            pCopy = allocType<VkPhysicalDeviceExternalFenceInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalFenceInfo));
            copyIndirectData(*static_cast<VkPhysicalDeviceExternalFenceInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
            pCopy = allocType<VkExternalFenceProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalFenceProperties));
            copyIndirectData(*static_cast<VkExternalFenceProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
            pCopy = allocType<VkExportFenceCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkExportFenceCreateInfo));
            copyIndirectData(*static_cast<VkExportFenceCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
            pCopy = allocType<VkImportFenceFdInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkImportFenceFdInfoKHR));
            copyIndirectData(*static_cast<VkImportFenceFdInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
            pCopy = allocType<VkFenceGetFdInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkFenceGetFdInfoKHR));
            copyIndirectData(*static_cast<VkFenceGetFdInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
            pCopy = allocType<VkPhysicalDeviceMultiviewFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiviewFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceMultiviewFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceMultiviewProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiviewProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceMultiviewProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
            pCopy = allocType<VkRenderPassMultiviewCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassMultiviewCreateInfo));
            copyIndirectData(*static_cast<VkRenderPassMultiviewCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
            pCopy = allocType<VkSurfaceCapabilities2EXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSurfaceCapabilities2EXT));
            copyIndirectData(*static_cast<VkSurfaceCapabilities2EXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
            pCopy = allocType<VkDisplayPowerInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayPowerInfoEXT));
            copyIndirectData(*static_cast<VkDisplayPowerInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
            pCopy = allocType<VkDeviceEventInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceEventInfoEXT));
            copyIndirectData(*static_cast<VkDeviceEventInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
            pCopy = allocType<VkDisplayEventInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayEventInfoEXT));
            copyIndirectData(*static_cast<VkDisplayEventInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
            pCopy = allocType<VkSwapchainCounterCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSwapchainCounterCreateInfoEXT));
            copyIndirectData(*static_cast<VkSwapchainCounterCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceGroupProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGroupProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceGroupProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
            pCopy = allocType<VkMemoryAllocateFlagsInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryAllocateFlagsInfo));
            copyIndirectData(*static_cast<VkMemoryAllocateFlagsInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
            pCopy = allocType<VkBindBufferMemoryInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBindBufferMemoryInfo));
            copyIndirectData(*static_cast<VkBindBufferMemoryInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
            pCopy = allocType<VkBindBufferMemoryDeviceGroupInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBindBufferMemoryDeviceGroupInfo));
            copyIndirectData(*static_cast<VkBindBufferMemoryDeviceGroupInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
            pCopy = allocType<VkBindImageMemoryInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBindImageMemoryInfo));
            copyIndirectData(*static_cast<VkBindImageMemoryInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
            pCopy = allocType<VkBindImageMemoryDeviceGroupInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBindImageMemoryDeviceGroupInfo));
            copyIndirectData(*static_cast<VkBindImageMemoryDeviceGroupInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
            pCopy = allocType<VkDeviceGroupRenderPassBeginInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupRenderPassBeginInfo));
            copyIndirectData(*static_cast<VkDeviceGroupRenderPassBeginInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
            pCopy = allocType<VkDeviceGroupCommandBufferBeginInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupCommandBufferBeginInfo));
            copyIndirectData(*static_cast<VkDeviceGroupCommandBufferBeginInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
            pCopy = allocType<VkDeviceGroupSubmitInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupSubmitInfo));
            copyIndirectData(*static_cast<VkDeviceGroupSubmitInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
            pCopy = allocType<VkDeviceGroupBindSparseInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupBindSparseInfo));
            copyIndirectData(*static_cast<VkDeviceGroupBindSparseInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
            pCopy = allocType<VkDeviceGroupPresentCapabilitiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupPresentCapabilitiesKHR));
            copyIndirectData(*static_cast<VkDeviceGroupPresentCapabilitiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
            pCopy = allocType<VkImageSwapchainCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkImageSwapchainCreateInfoKHR));
            copyIndirectData(*static_cast<VkImageSwapchainCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
            pCopy = allocType<VkBindImageMemorySwapchainInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkBindImageMemorySwapchainInfoKHR));
            copyIndirectData(*static_cast<VkBindImageMemorySwapchainInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
            pCopy = allocType<VkAcquireNextImageInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAcquireNextImageInfoKHR));
            copyIndirectData(*static_cast<VkAcquireNextImageInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
            pCopy = allocType<VkDeviceGroupPresentInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupPresentInfoKHR));
            copyIndirectData(*static_cast<VkDeviceGroupPresentInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
            pCopy = allocType<VkDeviceGroupDeviceCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupDeviceCreateInfo));
            copyIndirectData(*static_cast<VkDeviceGroupDeviceCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
            pCopy = allocType<VkDeviceGroupSwapchainCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupSwapchainCreateInfoKHR));
            copyIndirectData(*static_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
            pCopy = allocType<VkDescriptorUpdateTemplateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorUpdateTemplateCreateInfo));
            copyIndirectData(*static_cast<VkDescriptorUpdateTemplateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDevicePresentIdFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePresentIdFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
            pCopy = allocType<VkPresentIdKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPresentIdKHR));
            copyIndirectData(*static_cast<VkPresentIdKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDevicePresentWaitFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePresentWaitFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
            pCopy = allocType<VkHdrMetadataEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkHdrMetadataEXT));
            copyIndirectData(*static_cast<VkHdrMetadataEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
            pCopy = allocType<VkDisplayNativeHdrSurfaceCapabilitiesAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD));
            copyIndirectData(*static_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
            pCopy = allocType<VkSwapchainDisplayNativeHdrCreateInfoAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD));
            copyIndirectData(*static_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
            pCopy = allocType<VkPresentTimesInfoGOOGLE>();
            std::memcpy(pCopy, pNext, sizeof(VkPresentTimesInfoGOOGLE));
            copyIndirectData(*static_cast<VkPresentTimesInfoGOOGLE*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineViewportWScalingStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportWScalingStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineViewportSwizzleStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportSwizzleStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceDiscardRectanglePropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineDiscardRectangleStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
            pCopy = allocType<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX));
            copyIndirectData(*static_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
            pCopy = allocType<VkRenderPassInputAttachmentAspectCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassInputAttachmentAspectCreateInfo));
            copyIndirectData(*static_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
            pCopy = allocType<VkPhysicalDeviceSurfaceInfo2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSurfaceInfo2KHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
            pCopy = allocType<VkSurfaceCapabilities2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkSurfaceCapabilities2KHR));
            copyIndirectData(*static_cast<VkSurfaceCapabilities2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
            pCopy = allocType<VkSurfaceFormat2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkSurfaceFormat2KHR));
            copyIndirectData(*static_cast<VkSurfaceFormat2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
            pCopy = allocType<VkDisplayProperties2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayProperties2KHR));
            copyIndirectData(*static_cast<VkDisplayProperties2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
            pCopy = allocType<VkDisplayPlaneProperties2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayPlaneProperties2KHR));
            copyIndirectData(*static_cast<VkDisplayPlaneProperties2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
            pCopy = allocType<VkDisplayModeProperties2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayModeProperties2KHR));
            copyIndirectData(*static_cast<VkDisplayModeProperties2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
            pCopy = allocType<VkDisplayPlaneInfo2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayPlaneInfo2KHR));
            copyIndirectData(*static_cast<VkDisplayPlaneInfo2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
            pCopy = allocType<VkDisplayPlaneCapabilities2KHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDisplayPlaneCapabilities2KHR));
            copyIndirectData(*static_cast<VkDisplayPlaneCapabilities2KHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
            pCopy = allocType<VkSharedPresentSurfaceCapabilitiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkSharedPresentSurfaceCapabilitiesKHR));
            copyIndirectData(*static_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
            pCopy = allocType<VkPhysicalDevice16BitStorageFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevice16BitStorageFeatures));
            copyIndirectData(*static_cast<VkPhysicalDevice16BitStorageFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceSubgroupProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubgroupProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceSubgroupProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
            pCopy = allocType<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
            pCopy = allocType<VkBufferMemoryRequirementsInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferMemoryRequirementsInfo2));
            copyIndirectData(*static_cast<VkBufferMemoryRequirementsInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
            pCopy = allocType<VkDeviceBufferMemoryRequirements>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceBufferMemoryRequirements));
            copyIndirectData(*static_cast<VkDeviceBufferMemoryRequirements*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
            pCopy = allocType<VkImageMemoryRequirementsInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkImageMemoryRequirementsInfo2));
            copyIndirectData(*static_cast<VkImageMemoryRequirementsInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
            pCopy = allocType<VkImageSparseMemoryRequirementsInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkImageSparseMemoryRequirementsInfo2));
            copyIndirectData(*static_cast<VkImageSparseMemoryRequirementsInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
            pCopy = allocType<VkDeviceImageMemoryRequirements>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceImageMemoryRequirements));
            copyIndirectData(*static_cast<VkDeviceImageMemoryRequirements*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
            pCopy = allocType<VkMemoryRequirements2>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryRequirements2));
            copyIndirectData(*static_cast<VkMemoryRequirements2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
            pCopy = allocType<VkSparseImageMemoryRequirements2>();
            std::memcpy(pCopy, pNext, sizeof(VkSparseImageMemoryRequirements2));
            copyIndirectData(*static_cast<VkSparseImageMemoryRequirements2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
            pCopy = allocType<VkPhysicalDevicePointClippingProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePointClippingProperties));
            copyIndirectData(*static_cast<VkPhysicalDevicePointClippingProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
            pCopy = allocType<VkMemoryDedicatedRequirements>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryDedicatedRequirements));
            copyIndirectData(*static_cast<VkMemoryDedicatedRequirements*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
            pCopy = allocType<VkMemoryDedicatedAllocateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryDedicatedAllocateInfo));
            copyIndirectData(*static_cast<VkMemoryDedicatedAllocateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
            pCopy = allocType<VkImageViewUsageCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkImageViewUsageCreateInfo));
            copyIndirectData(*static_cast<VkImageViewUsageCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
            pCopy = allocType<VkPipelineTessellationDomainOriginStateCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineTessellationDomainOriginStateCreateInfo));
            copyIndirectData(*static_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
            pCopy = allocType<VkSamplerYcbcrConversionInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSamplerYcbcrConversionInfo));
            copyIndirectData(*static_cast<VkSamplerYcbcrConversionInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
            pCopy = allocType<VkSamplerYcbcrConversionCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSamplerYcbcrConversionCreateInfo));
            copyIndirectData(*static_cast<VkSamplerYcbcrConversionCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
            pCopy = allocType<VkBindImagePlaneMemoryInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBindImagePlaneMemoryInfo));
            copyIndirectData(*static_cast<VkBindImagePlaneMemoryInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
            pCopy = allocType<VkImagePlaneMemoryRequirementsInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkImagePlaneMemoryRequirementsInfo));
            copyIndirectData(*static_cast<VkImagePlaneMemoryRequirementsInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
            pCopy = allocType<VkPhysicalDeviceSamplerYcbcrConversionFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
            pCopy = allocType<VkSamplerYcbcrConversionImageFormatProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkSamplerYcbcrConversionImageFormatProperties));
            copyIndirectData(*static_cast<VkSamplerYcbcrConversionImageFormatProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
            pCopy = allocType<VkTextureLODGatherFormatPropertiesAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkTextureLODGatherFormatPropertiesAMD));
            copyIndirectData(*static_cast<VkTextureLODGatherFormatPropertiesAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
            pCopy = allocType<VkConditionalRenderingBeginInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkConditionalRenderingBeginInfoEXT));
            copyIndirectData(*static_cast<VkConditionalRenderingBeginInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
            pCopy = allocType<VkProtectedSubmitInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkProtectedSubmitInfo));
            copyIndirectData(*static_cast<VkProtectedSubmitInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
            pCopy = allocType<VkPhysicalDeviceProtectedMemoryFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceProtectedMemoryProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProtectedMemoryProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceProtectedMemoryProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
            pCopy = allocType<VkDeviceQueueInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceQueueInfo2));
            copyIndirectData(*static_cast<VkDeviceQueueInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineCoverageToColorStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineCoverageToColorStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceSamplerFilterMinmaxProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
            pCopy = allocType<VkSampleLocationsInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSampleLocationsInfoEXT));
            copyIndirectData(*static_cast<VkSampleLocationsInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
            pCopy = allocType<VkRenderPassSampleLocationsBeginInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassSampleLocationsBeginInfoEXT));
            copyIndirectData(*static_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineSampleLocationsStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineSampleLocationsStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceSampleLocationsPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
            pCopy = allocType<VkMultisamplePropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkMultisamplePropertiesEXT));
            copyIndirectData(*static_cast<VkMultisamplePropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
            pCopy = allocType<VkSamplerReductionModeCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSamplerReductionModeCreateInfo));
            copyIndirectData(*static_cast<VkSamplerReductionModeCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceMultiDrawFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineColorBlendAdvancedStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
            pCopy = allocType<VkPhysicalDeviceInlineUniformBlockFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInlineUniformBlockFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceInlineUniformBlockProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInlineUniformBlockProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
            pCopy = allocType<VkWriteDescriptorSetInlineUniformBlock>();
            std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSetInlineUniformBlock));
            copyIndirectData(*static_cast<VkWriteDescriptorSetInlineUniformBlock*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
            pCopy = allocType<VkDescriptorPoolInlineUniformBlockCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo));
            copyIndirectData(*static_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineCoverageModulationStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineCoverageModulationStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
            pCopy = allocType<VkImageFormatListCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkImageFormatListCreateInfo));
            copyIndirectData(*static_cast<VkImageFormatListCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
            pCopy = allocType<VkValidationCacheCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkValidationCacheCreateInfoEXT));
            copyIndirectData(*static_cast<VkValidationCacheCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
            pCopy = allocType<VkShaderModuleValidationCacheCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkShaderModuleValidationCacheCreateInfoEXT));
            copyIndirectData(*static_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceMaintenance3Properties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMaintenance3Properties));
            copyIndirectData(*static_cast<VkPhysicalDeviceMaintenance3Properties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
            pCopy = allocType<VkPhysicalDeviceMaintenance4Features>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMaintenance4Features));
            copyIndirectData(*static_cast<VkPhysicalDeviceMaintenance4Features*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceMaintenance4Properties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMaintenance4Properties));
            copyIndirectData(*static_cast<VkPhysicalDeviceMaintenance4Properties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
            pCopy = allocType<VkDescriptorSetLayoutSupport>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutSupport));
            copyIndirectData(*static_cast<VkDescriptorSetLayoutSupport*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
            pCopy = allocType<VkPhysicalDeviceShaderDrawParametersFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
            pCopy = allocType<VkPhysicalDeviceShaderFloat16Int8Features>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderFloat16Int8Features));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceFloatControlsProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFloatControlsProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceFloatControlsProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
            pCopy = allocType<VkPhysicalDeviceHostQueryResetFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceHostQueryResetFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceHostQueryResetFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
            pCopy = allocType<VkDeviceQueueGlobalPriorityCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceQueueGlobalPriorityCreateInfoKHR));
            copyIndirectData(*static_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
            pCopy = allocType<VkQueueFamilyGlobalPriorityPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyGlobalPriorityPropertiesKHR));
            copyIndirectData(*static_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
            pCopy = allocType<VkDebugUtilsObjectNameInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsObjectNameInfoEXT));
            copyIndirectData(*static_cast<VkDebugUtilsObjectNameInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
            pCopy = allocType<VkDebugUtilsObjectTagInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsObjectTagInfoEXT));
            copyIndirectData(*static_cast<VkDebugUtilsObjectTagInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
            pCopy = allocType<VkDebugUtilsLabelEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsLabelEXT));
            copyIndirectData(*static_cast<VkDebugUtilsLabelEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
            pCopy = allocType<VkDebugUtilsMessengerCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsMessengerCreateInfoEXT));
            copyIndirectData(*static_cast<VkDebugUtilsMessengerCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
            pCopy = allocType<VkDebugUtilsMessengerCallbackDataEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsMessengerCallbackDataEXT));
            copyIndirectData(*static_cast<VkDebugUtilsMessengerCallbackDataEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
            pCopy = allocType<VkDeviceDeviceMemoryReportCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceDeviceMemoryReportCreateInfoEXT));
            copyIndirectData(*static_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
            pCopy = allocType<VkDeviceMemoryReportCallbackDataEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceMemoryReportCallbackDataEXT));
            copyIndirectData(*static_cast<VkDeviceMemoryReportCallbackDataEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
            pCopy = allocType<VkImportMemoryHostPointerInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMemoryHostPointerInfoEXT));
            copyIndirectData(*static_cast<VkImportMemoryHostPointerInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
            pCopy = allocType<VkMemoryHostPointerPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryHostPointerPropertiesEXT));
            copyIndirectData(*static_cast<VkMemoryHostPointerPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceExternalMemoryHostPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT:
            pCopy = allocType<VkCalibratedTimestampInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkCalibratedTimestampInfoEXT));
            copyIndirectData(*static_cast<VkCalibratedTimestampInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
            pCopy = allocType<VkPhysicalDeviceShaderCorePropertiesAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderCorePropertiesAMD));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
            pCopy = allocType<VkPhysicalDeviceShaderCoreProperties2AMD>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderCoreProperties2AMD));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineRasterizationConservativeStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
            pCopy = allocType<VkPhysicalDeviceDescriptorIndexingFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceDescriptorIndexingProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDescriptorIndexingProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
            pCopy = allocType<VkDescriptorSetLayoutBindingFlagsCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo));
            copyIndirectData(*static_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
            pCopy = allocType<VkDescriptorSetVariableDescriptorCountAllocateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo));
            copyIndirectData(*static_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
            pCopy = allocType<VkDescriptorSetVariableDescriptorCountLayoutSupport>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport));
            copyIndirectData(*static_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
            pCopy = allocType<VkAttachmentDescription2>();
            std::memcpy(pCopy, pNext, sizeof(VkAttachmentDescription2));
            copyIndirectData(*static_cast<VkAttachmentDescription2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
            pCopy = allocType<VkAttachmentReference2>();
            std::memcpy(pCopy, pNext, sizeof(VkAttachmentReference2));
            copyIndirectData(*static_cast<VkAttachmentReference2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
            pCopy = allocType<VkSubpassDescription2>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassDescription2));
            copyIndirectData(*static_cast<VkSubpassDescription2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
            pCopy = allocType<VkSubpassDependency2>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassDependency2));
            copyIndirectData(*static_cast<VkSubpassDependency2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
            pCopy = allocType<VkRenderPassCreateInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreateInfo2));
            copyIndirectData(*static_cast<VkRenderPassCreateInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
            pCopy = allocType<VkSubpassBeginInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassBeginInfo));
            copyIndirectData(*static_cast<VkSubpassBeginInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
            pCopy = allocType<VkSubpassEndInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassEndInfo));
            copyIndirectData(*static_cast<VkSubpassEndInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
            pCopy = allocType<VkPhysicalDeviceTimelineSemaphoreFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceTimelineSemaphoreProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTimelineSemaphoreProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
            pCopy = allocType<VkSemaphoreTypeCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreTypeCreateInfo));
            copyIndirectData(*static_cast<VkSemaphoreTypeCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
            pCopy = allocType<VkTimelineSemaphoreSubmitInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkTimelineSemaphoreSubmitInfo));
            copyIndirectData(*static_cast<VkTimelineSemaphoreSubmitInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
            pCopy = allocType<VkSemaphoreWaitInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreWaitInfo));
            copyIndirectData(*static_cast<VkSemaphoreWaitInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
            pCopy = allocType<VkSemaphoreSignalInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreSignalInfo));
            copyIndirectData(*static_cast<VkSemaphoreSignalInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineVertexInputDivisorStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDevicePCIBusInfoPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
            pCopy = allocType<VkCommandBufferInheritanceConditionalRenderingInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT));
            copyIndirectData(*static_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
            pCopy = allocType<VkPhysicalDevice8BitStorageFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevice8BitStorageFeatures));
            copyIndirectData(*static_cast<VkPhysicalDevice8BitStorageFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
            pCopy = allocType<VkPhysicalDeviceVulkanMemoryModelFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
            pCopy = allocType<VkPhysicalDeviceShaderAtomicInt64Features>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderAtomicInt64Features));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
            pCopy = allocType<VkQueueFamilyCheckpointPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyCheckpointPropertiesNV));
            copyIndirectData(*static_cast<VkQueueFamilyCheckpointPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
            pCopy = allocType<VkCheckpointDataNV>();
            std::memcpy(pCopy, pNext, sizeof(VkCheckpointDataNV));
            copyIndirectData(*static_cast<VkCheckpointDataNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceDepthStencilResolveProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDepthStencilResolveProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
            pCopy = allocType<VkSubpassDescriptionDepthStencilResolve>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassDescriptionDepthStencilResolve));
            copyIndirectData(*static_cast<VkSubpassDescriptionDepthStencilResolve*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
            pCopy = allocType<VkImageViewASTCDecodeModeEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageViewASTCDecodeModeEXT));
            copyIndirectData(*static_cast<VkImageViewASTCDecodeModeEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceASTCDecodeFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceTransformFeedbackPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineRasterizationStateStreamCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineRepresentativeFragmentTestStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceExclusiveScissorFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExclusiveScissorFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineViewportExclusiveScissorStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceCornerSampledImageFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCornerSampledImageFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceShaderImageFootprintFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineViewportShadingRateImageStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportShadingRateImageStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceShadingRateImageFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShadingRateImageFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
            pCopy = allocType<VkPhysicalDeviceShadingRateImagePropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShadingRateImagePropertiesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
            pCopy = allocType<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI));
            copyIndirectData(*static_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceMeshShaderFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMeshShaderFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
            pCopy = allocType<VkPhysicalDeviceMeshShaderPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMeshShaderPropertiesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
            pCopy = allocType<VkRayTracingShaderGroupCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkRayTracingShaderGroupCreateInfoNV));
            copyIndirectData(*static_cast<VkRayTracingShaderGroupCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
            pCopy = allocType<VkRayTracingShaderGroupCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkRayTracingShaderGroupCreateInfoKHR));
            copyIndirectData(*static_cast<VkRayTracingShaderGroupCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
            pCopy = allocType<VkRayTracingPipelineCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkRayTracingPipelineCreateInfoNV));
            copyIndirectData(*static_cast<VkRayTracingPipelineCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
            pCopy = allocType<VkRayTracingPipelineCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkRayTracingPipelineCreateInfoKHR));
            copyIndirectData(*static_cast<VkRayTracingPipelineCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
            pCopy = allocType<VkGeometryTrianglesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkGeometryTrianglesNV));
            copyIndirectData(*static_cast<VkGeometryTrianglesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
            pCopy = allocType<VkGeometryAABBNV>();
            std::memcpy(pCopy, pNext, sizeof(VkGeometryAABBNV));
            copyIndirectData(*static_cast<VkGeometryAABBNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GEOMETRY_NV:
            pCopy = allocType<VkGeometryNV>();
            std::memcpy(pCopy, pNext, sizeof(VkGeometryNV));
            copyIndirectData(*static_cast<VkGeometryNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
            pCopy = allocType<VkAccelerationStructureInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureInfoNV));
            copyIndirectData(*static_cast<VkAccelerationStructureInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            pCopy = allocType<VkAccelerationStructureCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureCreateInfoNV));
            copyIndirectData(*static_cast<VkAccelerationStructureCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
            pCopy = allocType<VkBindAccelerationStructureMemoryInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkBindAccelerationStructureMemoryInfoNV));
            copyIndirectData(*static_cast<VkBindAccelerationStructureMemoryInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
            pCopy = allocType<VkWriteDescriptorSetAccelerationStructureKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSetAccelerationStructureKHR));
            copyIndirectData(*static_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
            pCopy = allocType<VkWriteDescriptorSetAccelerationStructureNV>();
            std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSetAccelerationStructureNV));
            copyIndirectData(*static_cast<VkWriteDescriptorSetAccelerationStructureNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
            pCopy = allocType<VkAccelerationStructureMemoryRequirementsInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureMemoryRequirementsInfoNV));
            copyIndirectData(*static_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceAccelerationStructureFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceRayQueryFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayQueryFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
            pCopy = allocType<VkPhysicalDeviceAccelerationStructurePropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
            pCopy = allocType<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
            pCopy = allocType<VkPhysicalDeviceRayTracingPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingPropertiesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
            pCopy = allocType<VkDrmFormatModifierPropertiesListEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDrmFormatModifierPropertiesListEXT));
            copyIndirectData(*static_cast<VkDrmFormatModifierPropertiesListEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
            pCopy = allocType<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
            pCopy = allocType<VkImageDrmFormatModifierListCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageDrmFormatModifierListCreateInfoEXT));
            copyIndirectData(*static_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
            pCopy = allocType<VkImageDrmFormatModifierExplicitCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT));
            copyIndirectData(*static_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
            pCopy = allocType<VkImageDrmFormatModifierPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageDrmFormatModifierPropertiesEXT));
            copyIndirectData(*static_cast<VkImageDrmFormatModifierPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
            pCopy = allocType<VkImageStencilUsageCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkImageStencilUsageCreateInfo));
            copyIndirectData(*static_cast<VkImageStencilUsageCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
            pCopy = allocType<VkDeviceMemoryOverallocationCreateInfoAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceMemoryOverallocationCreateInfoAMD));
            copyIndirectData(*static_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
            pCopy = allocType<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceFragmentDensityMapPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
            pCopy = allocType<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
            pCopy = allocType<VkRenderPassFragmentDensityMapCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT));
            copyIndirectData(*static_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
            pCopy = allocType<VkSubpassFragmentDensityMapOffsetEndInfoQCOM>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassFragmentDensityMapOffsetEndInfoQCOM));
            copyIndirectData(*static_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
            pCopy = allocType<VkPhysicalDeviceScalarBlockLayoutFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
            pCopy = allocType<VkSurfaceProtectedCapabilitiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkSurfaceProtectedCapabilitiesKHR));
            copyIndirectData(*static_cast<VkSurfaceProtectedCapabilitiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
            pCopy = allocType<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceDepthClipEnableFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineRasterizationDepthClipStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceMemoryBudgetPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceMemoryPriorityFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
            pCopy = allocType<VkMemoryPriorityAllocateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryPriorityAllocateInfoEXT));
            copyIndirectData(*static_cast<VkMemoryPriorityAllocateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
            pCopy = allocType<VkPhysicalDeviceBufferDeviceAddressFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
            pCopy = allocType<VkBufferDeviceAddressInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferDeviceAddressInfo));
            copyIndirectData(*static_cast<VkBufferDeviceAddressInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
            pCopy = allocType<VkBufferOpaqueCaptureAddressCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferOpaqueCaptureAddressCreateInfo));
            copyIndirectData(*static_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
            pCopy = allocType<VkBufferDeviceAddressCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferDeviceAddressCreateInfoEXT));
            copyIndirectData(*static_cast<VkBufferDeviceAddressCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
            pCopy = allocType<VkPhysicalDeviceImageViewImageFormatInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
            pCopy = allocType<VkFilterCubicImageViewImageFormatPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT));
            copyIndirectData(*static_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
            pCopy = allocType<VkPhysicalDeviceImagelessFramebufferFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
            pCopy = allocType<VkFramebufferAttachmentsCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkFramebufferAttachmentsCreateInfo));
            copyIndirectData(*static_cast<VkFramebufferAttachmentsCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
            pCopy = allocType<VkFramebufferAttachmentImageInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkFramebufferAttachmentImageInfo));
            copyIndirectData(*static_cast<VkFramebufferAttachmentImageInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
            pCopy = allocType<VkRenderPassAttachmentBeginInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassAttachmentBeginInfo));
            copyIndirectData(*static_cast<VkRenderPassAttachmentBeginInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
            pCopy = allocType<VkPhysicalDeviceTextureCompressionASTCHDRFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceCooperativeMatrixFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            pCopy = allocType<VkPhysicalDeviceCooperativeMatrixPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            pCopy = allocType<VkCooperativeMatrixPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkCooperativeMatrixPropertiesNV));
            copyIndirectData(*static_cast<VkCooperativeMatrixPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
            pCopy = allocType<VkImageViewHandleInfoNVX>();
            std::memcpy(pCopy, pNext, sizeof(VkImageViewHandleInfoNVX));
            copyIndirectData(*static_cast<VkImageViewHandleInfoNVX*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
            pCopy = allocType<VkImageViewAddressPropertiesNVX>();
            std::memcpy(pCopy, pNext, sizeof(VkImageViewAddressPropertiesNVX));
            copyIndirectData(*static_cast<VkImageViewAddressPropertiesNVX*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
            pCopy = allocType<VkPipelineCreationFeedbackCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineCreationFeedbackCreateInfo));
            copyIndirectData(*static_cast<VkPipelineCreationFeedbackCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDevicePerformanceQueryFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
            pCopy = allocType<VkPhysicalDevicePerformanceQueryPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
            pCopy = allocType<VkPerformanceCounterKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPerformanceCounterKHR));
            copyIndirectData(*static_cast<VkPerformanceCounterKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
            pCopy = allocType<VkPerformanceCounterDescriptionKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPerformanceCounterDescriptionKHR));
            copyIndirectData(*static_cast<VkPerformanceCounterDescriptionKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
            pCopy = allocType<VkQueryPoolPerformanceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkQueryPoolPerformanceCreateInfoKHR));
            copyIndirectData(*static_cast<VkQueryPoolPerformanceCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
            pCopy = allocType<VkAcquireProfilingLockInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAcquireProfilingLockInfoKHR));
            copyIndirectData(*static_cast<VkAcquireProfilingLockInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
            pCopy = allocType<VkPerformanceQuerySubmitInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPerformanceQuerySubmitInfoKHR));
            copyIndirectData(*static_cast<VkPerformanceQuerySubmitInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
            pCopy = allocType<VkHeadlessSurfaceCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkHeadlessSurfaceCreateInfoEXT));
            copyIndirectData(*static_cast<VkHeadlessSurfaceCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceCoverageReductionModeFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineCoverageReductionStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineCoverageReductionStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
            pCopy = allocType<VkFramebufferMixedSamplesCombinationNV>();
            std::memcpy(pCopy, pNext, sizeof(VkFramebufferMixedSamplesCombinationNV));
            copyIndirectData(*static_cast<VkFramebufferMixedSamplesCombinationNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
            pCopy = allocType<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
            pCopy = allocType<VkInitializePerformanceApiInfoINTEL>();
            std::memcpy(pCopy, pNext, sizeof(VkInitializePerformanceApiInfoINTEL));
            copyIndirectData(*static_cast<VkInitializePerformanceApiInfoINTEL*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
            pCopy = allocType<VkQueryPoolPerformanceQueryCreateInfoINTEL>();
            std::memcpy(pCopy, pNext, sizeof(VkQueryPoolPerformanceQueryCreateInfoINTEL));
            copyIndirectData(*static_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
            pCopy = allocType<VkPerformanceMarkerInfoINTEL>();
            std::memcpy(pCopy, pNext, sizeof(VkPerformanceMarkerInfoINTEL));
            copyIndirectData(*static_cast<VkPerformanceMarkerInfoINTEL*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
            pCopy = allocType<VkPerformanceStreamMarkerInfoINTEL>();
            std::memcpy(pCopy, pNext, sizeof(VkPerformanceStreamMarkerInfoINTEL));
            copyIndirectData(*static_cast<VkPerformanceStreamMarkerInfoINTEL*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
            pCopy = allocType<VkPerformanceOverrideInfoINTEL>();
            std::memcpy(pCopy, pNext, sizeof(VkPerformanceOverrideInfoINTEL));
            copyIndirectData(*static_cast<VkPerformanceOverrideInfoINTEL*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
            pCopy = allocType<VkPerformanceConfigurationAcquireInfoINTEL>();
            std::memcpy(pCopy, pNext, sizeof(VkPerformanceConfigurationAcquireInfoINTEL));
            copyIndirectData(*static_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceShaderClockFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
            pCopy = allocType<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
            pCopy = allocType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
            pCopy = allocType<VkAttachmentReferenceStencilLayout>();
            std::memcpy(pCopy, pNext, sizeof(VkAttachmentReferenceStencilLayout));
            copyIndirectData(*static_cast<VkAttachmentReferenceStencilLayout*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
            pCopy = allocType<VkAttachmentDescriptionStencilLayout>();
            std::memcpy(pCopy, pNext, sizeof(VkAttachmentDescriptionStencilLayout));
            copyIndirectData(*static_cast<VkAttachmentDescriptionStencilLayout*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
            pCopy = allocType<VkPipelineInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineInfoKHR));
            copyIndirectData(*static_cast<VkPipelineInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
            pCopy = allocType<VkPipelineExecutablePropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutablePropertiesKHR));
            copyIndirectData(*static_cast<VkPipelineExecutablePropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
            pCopy = allocType<VkPipelineExecutableInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutableInfoKHR));
            copyIndirectData(*static_cast<VkPipelineExecutableInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
            pCopy = allocType<VkPipelineExecutableStatisticKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutableStatisticKHR));
            copyIndirectData(*static_cast<VkPipelineExecutableStatisticKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
            pCopy = allocType<VkPipelineExecutableInternalRepresentationKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutableInternalRepresentationKHR));
            copyIndirectData(*static_cast<VkPipelineExecutableInternalRepresentationKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
            pCopy = allocType<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceTexelBufferAlignmentProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
            pCopy = allocType<VkPhysicalDeviceSubgroupSizeControlFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceSubgroupSizeControlProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubgroupSizeControlProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
            pCopy = allocType<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo));
            copyIndirectData(*static_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
            pCopy = allocType<VkSubpassShadingPipelineCreateInfoHUAWEI>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassShadingPipelineCreateInfoHUAWEI));
            copyIndirectData(*static_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
            pCopy = allocType<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI));
            copyIndirectData(*static_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
            pCopy = allocType<VkMemoryOpaqueCaptureAddressAllocateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo));
            copyIndirectData(*static_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
            pCopy = allocType<VkDeviceMemoryOpaqueCaptureAddressInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceMemoryOpaqueCaptureAddressInfo));
            copyIndirectData(*static_cast<VkDeviceMemoryOpaqueCaptureAddressInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceLineRasterizationPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineRasterizationLineStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationLineStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
            pCopy = allocType<VkPhysicalDevicePipelineCreationCacheControlFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures));
            copyIndirectData(*static_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
            pCopy = allocType<VkPhysicalDeviceVulkan11Features>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan11Features));
            copyIndirectData(*static_cast<VkPhysicalDeviceVulkan11Features*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceVulkan11Properties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan11Properties));
            copyIndirectData(*static_cast<VkPhysicalDeviceVulkan11Properties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
            pCopy = allocType<VkPhysicalDeviceVulkan12Features>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan12Features));
            copyIndirectData(*static_cast<VkPhysicalDeviceVulkan12Features*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceVulkan12Properties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan12Properties));
            copyIndirectData(*static_cast<VkPhysicalDeviceVulkan12Properties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
            pCopy = allocType<VkPhysicalDeviceVulkan13Features>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan13Features));
            copyIndirectData(*static_cast<VkPhysicalDeviceVulkan13Features*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceVulkan13Properties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan13Properties));
            copyIndirectData(*static_cast<VkPhysicalDeviceVulkan13Properties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
            pCopy = allocType<VkPipelineCompilerControlCreateInfoAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineCompilerControlCreateInfoAMD));
            copyIndirectData(*static_cast<VkPipelineCompilerControlCreateInfoAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
            pCopy = allocType<VkPhysicalDeviceCoherentMemoryFeaturesAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD));
            copyIndirectData(*static_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceToolProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceToolProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceToolProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
            pCopy = allocType<VkSamplerCustomBorderColorCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSamplerCustomBorderColorCreateInfoEXT));
            copyIndirectData(*static_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceCustomBorderColorPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceCustomBorderColorFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
            pCopy = allocType<VkSamplerBorderColorComponentMappingCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSamplerBorderColorComponentMappingCreateInfoEXT));
            copyIndirectData(*static_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
            pCopy = allocType<VkAccelerationStructureGeometryTrianglesDataKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryTrianglesDataKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureGeometryTrianglesDataKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
            pCopy = allocType<VkAccelerationStructureGeometryAabbsDataKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryAabbsDataKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureGeometryAabbsDataKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
            pCopy = allocType<VkAccelerationStructureGeometryInstancesDataKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryInstancesDataKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureGeometryInstancesDataKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
            pCopy = allocType<VkAccelerationStructureGeometryKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureGeometryKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
            pCopy = allocType<VkAccelerationStructureBuildGeometryInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureBuildGeometryInfoKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureBuildGeometryInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
            pCopy = allocType<VkAccelerationStructureCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureCreateInfoKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
            pCopy = allocType<VkAccelerationStructureDeviceAddressInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureDeviceAddressInfoKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureDeviceAddressInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
            pCopy = allocType<VkAccelerationStructureVersionInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureVersionInfoKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureVersionInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
            pCopy = allocType<VkCopyAccelerationStructureInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyAccelerationStructureInfoKHR));
            copyIndirectData(*static_cast<VkCopyAccelerationStructureInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
            pCopy = allocType<VkCopyAccelerationStructureToMemoryInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyAccelerationStructureToMemoryInfoKHR));
            copyIndirectData(*static_cast<VkCopyAccelerationStructureToMemoryInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
            pCopy = allocType<VkCopyMemoryToAccelerationStructureInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyMemoryToAccelerationStructureInfoKHR));
            copyIndirectData(*static_cast<VkCopyMemoryToAccelerationStructureInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
            pCopy = allocType<VkRayTracingPipelineInterfaceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkRayTracingPipelineInterfaceCreateInfoKHR));
            copyIndirectData(*static_cast<VkRayTracingPipelineInterfaceCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
            pCopy = allocType<VkPipelineLibraryCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineLibraryCreateInfoKHR));
            copyIndirectData(*static_cast<VkPipelineLibraryCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
            pCopy = allocType<VkRenderPassTransformBeginInfoQCOM>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassTransformBeginInfoQCOM));
            copyIndirectData(*static_cast<VkRenderPassTransformBeginInfoQCOM*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
            pCopy = allocType<VkCopyCommandTransformInfoQCOM>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyCommandTransformInfoQCOM));
            copyIndirectData(*static_cast<VkCopyCommandTransformInfoQCOM*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
            pCopy = allocType<VkCommandBufferInheritanceRenderPassTransformInfoQCOM>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM));
            copyIndirectData(*static_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceDiagnosticsConfigFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
            pCopy = allocType<VkDeviceDiagnosticsConfigCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkDeviceDiagnosticsConfigCreateInfoNV));
            copyIndirectData(*static_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
            pCopy = allocType<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceRobustness2FeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRobustness2FeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceRobustness2PropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRobustness2PropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
            pCopy = allocType<VkPhysicalDeviceImageRobustnessFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageRobustnessFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceImageRobustnessFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDevice4444FormatsFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevice4444FormatsFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
            pCopy = allocType<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI));
            copyIndirectData(*static_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
            pCopy = allocType<VkBufferCopy2>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferCopy2));
            copyIndirectData(*static_cast<VkBufferCopy2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
            pCopy = allocType<VkImageCopy2>();
            std::memcpy(pCopy, pNext, sizeof(VkImageCopy2));
            copyIndirectData(*static_cast<VkImageCopy2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
            pCopy = allocType<VkImageBlit2>();
            std::memcpy(pCopy, pNext, sizeof(VkImageBlit2));
            copyIndirectData(*static_cast<VkImageBlit2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
            pCopy = allocType<VkBufferImageCopy2>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferImageCopy2));
            copyIndirectData(*static_cast<VkBufferImageCopy2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
            pCopy = allocType<VkImageResolve2>();
            std::memcpy(pCopy, pNext, sizeof(VkImageResolve2));
            copyIndirectData(*static_cast<VkImageResolve2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
            pCopy = allocType<VkCopyBufferInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyBufferInfo2));
            copyIndirectData(*static_cast<VkCopyBufferInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
            pCopy = allocType<VkCopyImageInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyImageInfo2));
            copyIndirectData(*static_cast<VkCopyImageInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
            pCopy = allocType<VkBlitImageInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkBlitImageInfo2));
            copyIndirectData(*static_cast<VkBlitImageInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
            pCopy = allocType<VkCopyBufferToImageInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyBufferToImageInfo2));
            copyIndirectData(*static_cast<VkCopyBufferToImageInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
            pCopy = allocType<VkCopyImageToBufferInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkCopyImageToBufferInfo2));
            copyIndirectData(*static_cast<VkCopyImageToBufferInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
            pCopy = allocType<VkResolveImageInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkResolveImageInfo2));
            copyIndirectData(*static_cast<VkResolveImageInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            pCopy = allocType<VkFragmentShadingRateAttachmentInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkFragmentShadingRateAttachmentInfoKHR));
            copyIndirectData(*static_cast<VkFragmentShadingRateAttachmentInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
            pCopy = allocType<VkPipelineFragmentShadingRateStateCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR));
            copyIndirectData(*static_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
            pCopy = allocType<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
            pCopy = allocType<VkPhysicalDeviceFragmentShadingRateKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShadingRateKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
            pCopy = allocType<VkPhysicalDeviceShaderTerminateInvocationFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
            pCopy = allocType<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
            pCopy = allocType<VkPipelineFragmentShadingRateEnumStateCreateInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV));
            copyIndirectData(*static_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
            pCopy = allocType<VkAccelerationStructureBuildSizesInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureBuildSizesInfoKHR));
            copyIndirectData(*static_cast<VkAccelerationStructureBuildSizesInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
            pCopy = allocType<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE));
            copyIndirectData(*static_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
            pCopy = allocType<VkMutableDescriptorTypeCreateInfoVALVE>();
            std::memcpy(pCopy, pNext, sizeof(VkMutableDescriptorTypeCreateInfoVALVE));
            copyIndirectData(*static_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceDepthClipControlFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineViewportDepthClipControlCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
            pCopy = allocType<VkVertexInputBindingDescription2EXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVertexInputBindingDescription2EXT));
            copyIndirectData(*static_cast<VkVertexInputBindingDescription2EXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
            pCopy = allocType<VkVertexInputAttributeDescription2EXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVertexInputAttributeDescription2EXT));
            copyIndirectData(*static_cast<VkVertexInputAttributeDescription2EXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceColorWriteEnableFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineColorWriteCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineColorWriteCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineColorWriteCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
            pCopy = allocType<VkMemoryBarrier2>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryBarrier2));
            copyIndirectData(*static_cast<VkMemoryBarrier2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
            pCopy = allocType<VkImageMemoryBarrier2>();
            std::memcpy(pCopy, pNext, sizeof(VkImageMemoryBarrier2));
            copyIndirectData(*static_cast<VkImageMemoryBarrier2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
            pCopy = allocType<VkBufferMemoryBarrier2>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferMemoryBarrier2));
            copyIndirectData(*static_cast<VkBufferMemoryBarrier2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
            pCopy = allocType<VkDependencyInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkDependencyInfo));
            copyIndirectData(*static_cast<VkDependencyInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
            pCopy = allocType<VkSemaphoreSubmitInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreSubmitInfo));
            copyIndirectData(*static_cast<VkSemaphoreSubmitInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
            pCopy = allocType<VkCommandBufferSubmitInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferSubmitInfo));
            copyIndirectData(*static_cast<VkCommandBufferSubmitInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
            pCopy = allocType<VkSubmitInfo2>();
            std::memcpy(pCopy, pNext, sizeof(VkSubmitInfo2));
            copyIndirectData(*static_cast<VkSubmitInfo2*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
            pCopy = allocType<VkQueueFamilyCheckpointProperties2NV>();
            std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyCheckpointProperties2NV));
            copyIndirectData(*static_cast<VkQueueFamilyCheckpointProperties2NV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
            pCopy = allocType<VkCheckpointData2NV>();
            std::memcpy(pCopy, pNext, sizeof(VkCheckpointData2NV));
            copyIndirectData(*static_cast<VkCheckpointData2NV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
            pCopy = allocType<VkPhysicalDeviceSynchronization2Features>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSynchronization2Features));
            copyIndirectData(*static_cast<VkPhysicalDeviceSynchronization2Features*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
            pCopy = allocType<VkSubpassResolvePerformanceQueryEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSubpassResolvePerformanceQueryEXT));
            copyIndirectData(*static_cast<VkSubpassResolvePerformanceQueryEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
            pCopy = allocType<VkMultisampledRenderToSingleSampledInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkMultisampledRenderToSingleSampledInfoEXT));
            copyIndirectData(*static_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceInheritedViewportScissorFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
            pCopy = allocType<VkCommandBufferInheritanceViewportScissorInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceViewportScissorInfoNV));
            copyIndirectData(*static_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceProvokingVertexFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceProvokingVertexPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProvokingVertexPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
            pCopy = allocType<VkCuModuleCreateInfoNVX>();
            std::memcpy(pCopy, pNext, sizeof(VkCuModuleCreateInfoNVX));
            copyIndirectData(*static_cast<VkCuModuleCreateInfoNVX*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
            pCopy = allocType<VkCuFunctionCreateInfoNVX>();
            std::memcpy(pCopy, pNext, sizeof(VkCuFunctionCreateInfoNVX));
            copyIndirectData(*static_cast<VkCuFunctionCreateInfoNVX*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
            pCopy = allocType<VkCuLaunchInfoNVX>();
            std::memcpy(pCopy, pNext, sizeof(VkCuLaunchInfoNVX));
            copyIndirectData(*static_cast<VkCuLaunchInfoNVX*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
            pCopy = allocType<VkPhysicalDeviceShaderIntegerDotProductFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
            pCopy = allocType<VkPhysicalDeviceShaderIntegerDotProductProperties>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderIntegerDotProductProperties));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceDrmPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDrmPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceDrmPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
            pCopy = allocType<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
            pCopy = allocType<VkAccelerationStructureGeometryMotionTrianglesDataNV>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryMotionTrianglesDataNV));
            copyIndirectData(*static_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
            pCopy = allocType<VkAccelerationStructureMotionInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureMotionInfoNV));
            copyIndirectData(*static_cast<VkAccelerationStructureMotionInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV:
            pCopy = allocType<VkMemoryGetRemoteAddressInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryGetRemoteAddressInfoNV));
            copyIndirectData(*static_cast<VkMemoryGetRemoteAddressInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
            pCopy = allocType<VkFormatProperties3>();
            std::memcpy(pCopy, pNext, sizeof(VkFormatProperties3));
            copyIndirectData(*static_cast<VkFormatProperties3*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
            pCopy = allocType<VkDrmFormatModifierPropertiesList2EXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDrmFormatModifierPropertiesList2EXT));
            copyIndirectData(*static_cast<VkDrmFormatModifierPropertiesList2EXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
            pCopy = allocType<VkPipelineRenderingCreateInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRenderingCreateInfo));
            copyIndirectData(*static_cast<VkPipelineRenderingCreateInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_INFO:
            pCopy = allocType<VkRenderingInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderingInfo));
            copyIndirectData(*static_cast<VkRenderingInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
            pCopy = allocType<VkRenderingAttachmentInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderingAttachmentInfo));
            copyIndirectData(*static_cast<VkRenderingAttachmentInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            pCopy = allocType<VkRenderingFragmentShadingRateAttachmentInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR));
            copyIndirectData(*static_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
            pCopy = allocType<VkRenderingFragmentDensityMapAttachmentInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT));
            copyIndirectData(*static_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
            pCopy = allocType<VkPhysicalDeviceDynamicRenderingFeatures>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDynamicRenderingFeatures));
            copyIndirectData(*static_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
            pCopy = allocType<VkCommandBufferInheritanceRenderingInfo>();
            std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceRenderingInfo));
            copyIndirectData(*static_cast<VkCommandBufferInheritanceRenderingInfo*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
            pCopy = allocType<VkAttachmentSampleCountInfoAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkAttachmentSampleCountInfoAMD));
            copyIndirectData(*static_cast<VkAttachmentSampleCountInfoAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
            pCopy = allocType<VkMultiviewPerViewAttributesInfoNVX>();
            std::memcpy(pCopy, pNext, sizeof(VkMultiviewPerViewAttributesInfoNVX));
            copyIndirectData(*static_cast<VkMultiviewPerViewAttributesInfoNVX*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceImageViewMinLodFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
            pCopy = allocType<VkImageViewMinLodCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageViewMinLodCreateInfoEXT));
            copyIndirectData(*static_cast<VkImageViewMinLodCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
            pCopy = allocType<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV));
            copyIndirectData(*static_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
            pCopy = allocType<VkGraphicsPipelineLibraryCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkGraphicsPipelineLibraryCreateInfoEXT));
            copyIndirectData(*static_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
            pCopy = allocType<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE));
            copyIndirectData(*static_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE:
            pCopy = allocType<VkDescriptorSetBindingReferenceVALVE>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetBindingReferenceVALVE));
            copyIndirectData(*static_cast<VkDescriptorSetBindingReferenceVALVE*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
            pCopy = allocType<VkDescriptorSetLayoutHostMappingInfoVALVE>();
            std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutHostMappingInfoVALVE));
            copyIndirectData(*static_cast<VkDescriptorSetLayoutHostMappingInfoVALVE*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT:
            pCopy = allocType<VkShaderModuleIdentifierEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkShaderModuleIdentifierEXT));
            copyIndirectData(*static_cast<VkShaderModuleIdentifierEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
            pCopy = allocType<VkImageCompressionControlEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageCompressionControlEXT));
            copyIndirectData(*static_cast<VkImageCompressionControlEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceImageCompressionControlFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
            pCopy = allocType<VkImageCompressionPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageCompressionPropertiesEXT));
            copyIndirectData(*static_cast<VkImageCompressionPropertiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT:
            pCopy = allocType<VkImageSubresource2EXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImageSubresource2EXT));
            copyIndirectData(*static_cast<VkImageSubresource2EXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT:
            pCopy = allocType<VkSubresourceLayout2EXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSubresourceLayout2EXT));
            copyIndirectData(*static_cast<VkSubresourceLayout2EXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
            pCopy = allocType<VkRenderPassCreationControlEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreationControlEXT));
            copyIndirectData(*static_cast<VkRenderPassCreationControlEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
            pCopy = allocType<VkRenderPassCreationFeedbackCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreationFeedbackCreateInfoEXT));
            copyIndirectData(*static_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
            pCopy = allocType<VkRenderPassSubpassFeedbackCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkRenderPassSubpassFeedbackCreateInfoEXT));
            copyIndirectData(*static_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT:
            pCopy = allocType<VkPipelinePropertiesIdentifierEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelinePropertiesIdentifierEXT));
            copyIndirectData(*static_cast<VkPipelinePropertiesIdentifierEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDevicePipelinePropertiesFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
            pCopy = allocType<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD));
            copyIndirectData(*static_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
            pCopy = allocType<VkPhysicalDevicePipelineRobustnessFeaturesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineRobustnessFeaturesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
            pCopy = allocType<VkPipelineRobustnessCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPipelineRobustnessCreateInfoEXT));
            copyIndirectData(*static_cast<VkPipelineRobustnessCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
            pCopy = allocType<VkPhysicalDevicePipelineRobustnessPropertiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineRobustnessPropertiesEXT));
            copyIndirectData(*static_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(pCopy));
            break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

        case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
            pCopy = allocType<VkAndroidSurfaceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkAndroidSurfaceCreateInfoKHR));
            copyIndirectData(*static_cast<VkAndroidSurfaceCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
            pCopy = allocType<VkNativeBufferANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkNativeBufferANDROID));
            copyIndirectData(*static_cast<VkNativeBufferANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID:
            pCopy = allocType<VkSwapchainImageCreateInfoANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkSwapchainImageCreateInfoANDROID));
            copyIndirectData(*static_cast<VkSwapchainImageCreateInfoANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID:
            pCopy = allocType<VkPhysicalDevicePresentationPropertiesANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePresentationPropertiesANDROID));
            copyIndirectData(*static_cast<VkPhysicalDevicePresentationPropertiesANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            pCopy = allocType<VkImportAndroidHardwareBufferInfoANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkImportAndroidHardwareBufferInfoANDROID));
            copyIndirectData(*static_cast<VkImportAndroidHardwareBufferInfoANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
            pCopy = allocType<VkAndroidHardwareBufferUsageANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkAndroidHardwareBufferUsageANDROID));
            copyIndirectData(*static_cast<VkAndroidHardwareBufferUsageANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
            pCopy = allocType<VkAndroidHardwareBufferPropertiesANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkAndroidHardwareBufferPropertiesANDROID));
            copyIndirectData(*static_cast<VkAndroidHardwareBufferPropertiesANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            pCopy = allocType<VkMemoryGetAndroidHardwareBufferInfoANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryGetAndroidHardwareBufferInfoANDROID));
            copyIndirectData(*static_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
            pCopy = allocType<VkAndroidHardwareBufferFormatPropertiesANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID));
            copyIndirectData(*static_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
            pCopy = allocType<VkExternalFormatANDROID>();
            std::memcpy(pCopy, pNext, sizeof(VkExternalFormatANDROID));
            copyIndirectData(*static_cast<VkExternalFormatANDROID*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_ANDROID_KHR)

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

        case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
            pCopy = allocType<VkDirectFBSurfaceCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkDirectFBSurfaceCreateInfoEXT));
            copyIndirectData(*static_cast<VkDirectFBSurfaceCreateInfoEXT*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#if defined(VK_USE_PLATFORM_FUCHSIA)

        case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
            pCopy = allocType<VkImagePipeSurfaceCreateInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkImagePipeSurfaceCreateInfoFUCHSIA));
            copyIndirectData(*static_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
            pCopy = allocType<VkImportMemoryZirconHandleInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMemoryZirconHandleInfoFUCHSIA));
            copyIndirectData(*static_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
            pCopy = allocType<VkMemoryZirconHandlePropertiesFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryZirconHandlePropertiesFUCHSIA));
            copyIndirectData(*static_cast<VkMemoryZirconHandlePropertiesFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            pCopy = allocType<VkMemoryGetZirconHandleInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryGetZirconHandleInfoFUCHSIA));
            copyIndirectData(*static_cast<VkMemoryGetZirconHandleInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
            pCopy = allocType<VkImportSemaphoreZirconHandleInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkImportSemaphoreZirconHandleInfoFUCHSIA));
            copyIndirectData(*static_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            pCopy = allocType<VkSemaphoreGetZirconHandleInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreGetZirconHandleInfoFUCHSIA));
            copyIndirectData(*static_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
            pCopy = allocType<VkImportMemoryBufferCollectionFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMemoryBufferCollectionFUCHSIA));
            copyIndirectData(*static_cast<VkImportMemoryBufferCollectionFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
            pCopy = allocType<VkBufferCollectionImageCreateInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionImageCreateInfoFUCHSIA));
            copyIndirectData(*static_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
            pCopy = allocType<VkBufferCollectionBufferCreateInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionBufferCreateInfoFUCHSIA));
            copyIndirectData(*static_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
            pCopy = allocType<VkBufferCollectionCreateInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionCreateInfoFUCHSIA));
            copyIndirectData(*static_cast<VkBufferCollectionCreateInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
            pCopy = allocType<VkBufferCollectionPropertiesFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionPropertiesFUCHSIA));
            copyIndirectData(*static_cast<VkBufferCollectionPropertiesFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
            pCopy = allocType<VkBufferConstraintsInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferConstraintsInfoFUCHSIA));
            copyIndirectData(*static_cast<VkBufferConstraintsInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA:
            pCopy = allocType<VkSysmemColorSpaceFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkSysmemColorSpaceFUCHSIA));
            copyIndirectData(*static_cast<VkSysmemColorSpaceFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA:
            pCopy = allocType<VkImageFormatConstraintsInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkImageFormatConstraintsInfoFUCHSIA));
            copyIndirectData(*static_cast<VkImageFormatConstraintsInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA:
            pCopy = allocType<VkImageConstraintsInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkImageConstraintsInfoFUCHSIA));
            copyIndirectData(*static_cast<VkImageConstraintsInfoFUCHSIA*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA:
            pCopy = allocType<VkBufferCollectionConstraintsInfoFUCHSIA>();
            std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionConstraintsInfoFUCHSIA));
            copyIndirectData(*static_cast<VkBufferCollectionConstraintsInfoFUCHSIA*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_FUCHSIA)

#if defined(VK_USE_PLATFORM_GGP)

        case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
            pCopy = allocType<VkStreamDescriptorSurfaceCreateInfoGGP>();
            std::memcpy(pCopy, pNext, sizeof(VkStreamDescriptorSurfaceCreateInfoGGP));
            copyIndirectData(*static_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
            pCopy = allocType<VkPresentFrameTokenGGP>();
            std::memcpy(pCopy, pNext, sizeof(VkPresentFrameTokenGGP));
            copyIndirectData(*static_cast<VkPresentFrameTokenGGP*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_GGP)

#if defined(VK_USE_PLATFORM_IOS_MVK)

        case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
            pCopy = allocType<VkIOSSurfaceCreateInfoMVK>();
            std::memcpy(pCopy, pNext, sizeof(VkIOSSurfaceCreateInfoMVK));
            copyIndirectData(*static_cast<VkIOSSurfaceCreateInfoMVK*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_IOS_MVK)

#if defined(VK_USE_PLATFORM_MACOS_MVK)

        case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
            pCopy = allocType<VkMacOSSurfaceCreateInfoMVK>();
            std::memcpy(pCopy, pNext, sizeof(VkMacOSSurfaceCreateInfoMVK));
            copyIndirectData(*static_cast<VkMacOSSurfaceCreateInfoMVK*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_MACOS_MVK)

#if defined(VK_USE_PLATFORM_METAL_EXT)

        case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
            pCopy = allocType<VkMetalSurfaceCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkMetalSurfaceCreateInfoEXT));
            copyIndirectData(*static_cast<VkMetalSurfaceCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
            pCopy = allocType<VkExportMetalObjectCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalObjectCreateInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalObjectCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT:
            pCopy = allocType<VkExportMetalObjectsInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalObjectsInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalObjectsInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
            pCopy = allocType<VkExportMetalDeviceInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalDeviceInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalDeviceInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
            pCopy = allocType<VkExportMetalCommandQueueInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalCommandQueueInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalCommandQueueInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
            pCopy = allocType<VkExportMetalBufferInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalBufferInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalBufferInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
            pCopy = allocType<VkImportMetalBufferInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMetalBufferInfoEXT));
            copyIndirectData(*static_cast<VkImportMetalBufferInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
            pCopy = allocType<VkExportMetalTextureInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalTextureInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalTextureInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
            pCopy = allocType<VkImportMetalTextureInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMetalTextureInfoEXT));
            copyIndirectData(*static_cast<VkImportMetalTextureInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
            pCopy = allocType<VkExportMetalIOSurfaceInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalIOSurfaceInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalIOSurfaceInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
            pCopy = allocType<VkImportMetalIOSurfaceInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMetalIOSurfaceInfoEXT));
            copyIndirectData(*static_cast<VkImportMetalIOSurfaceInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
            pCopy = allocType<VkExportMetalSharedEventInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMetalSharedEventInfoEXT));
            copyIndirectData(*static_cast<VkExportMetalSharedEventInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
            pCopy = allocType<VkImportMetalSharedEventInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMetalSharedEventInfoEXT));
            copyIndirectData(*static_cast<VkImportMetalSharedEventInfoEXT*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_METAL_EXT)

#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
            pCopy = allocType<VkPhysicalDevicePortabilitySubsetFeaturesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
            pCopy = allocType<VkPhysicalDevicePortabilitySubsetPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR));
            copyIndirectData(*static_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
            pCopy = allocType<VkQueueFamilyVideoPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyVideoPropertiesKHR));
            copyIndirectData(*static_cast<VkQueueFamilyVideoPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
            pCopy = allocType<VkQueueFamilyQueryResultStatusPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyQueryResultStatusPropertiesKHR));
            copyIndirectData(*static_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
            pCopy = allocType<VkVideoProfileListInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoProfileListInfoKHR));
            copyIndirectData(*static_cast<VkVideoProfileListInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
            pCopy = allocType<VkPhysicalDeviceVideoFormatInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVideoFormatInfoKHR));
            copyIndirectData(*static_cast<VkPhysicalDeviceVideoFormatInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
            pCopy = allocType<VkVideoFormatPropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoFormatPropertiesKHR));
            copyIndirectData(*static_cast<VkVideoFormatPropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
            pCopy = allocType<VkVideoProfileInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoProfileInfoKHR));
            copyIndirectData(*static_cast<VkVideoProfileInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
            pCopy = allocType<VkVideoCapabilitiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoCapabilitiesKHR));
            copyIndirectData(*static_cast<VkVideoCapabilitiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR:
            pCopy = allocType<VkVideoSessionMemoryRequirementsKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoSessionMemoryRequirementsKHR));
            copyIndirectData(*static_cast<VkVideoSessionMemoryRequirementsKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR:
            pCopy = allocType<VkBindVideoSessionMemoryInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkBindVideoSessionMemoryInfoKHR));
            copyIndirectData(*static_cast<VkBindVideoSessionMemoryInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR:
            pCopy = allocType<VkVideoPictureResourceInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoPictureResourceInfoKHR));
            copyIndirectData(*static_cast<VkVideoPictureResourceInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR:
            pCopy = allocType<VkVideoReferenceSlotInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoReferenceSlotInfoKHR));
            copyIndirectData(*static_cast<VkVideoReferenceSlotInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
            pCopy = allocType<VkVideoDecodeCapabilitiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeCapabilitiesKHR));
            copyIndirectData(*static_cast<VkVideoDecodeCapabilitiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
            pCopy = allocType<VkVideoDecodeUsageInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeUsageInfoKHR));
            copyIndirectData(*static_cast<VkVideoDecodeUsageInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
            pCopy = allocType<VkVideoDecodeInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeInfoKHR));
            copyIndirectData(*static_cast<VkVideoDecodeInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH264ProfileInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264ProfileInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH264ProfileInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
            pCopy = allocType<VkVideoDecodeH264CapabilitiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264CapabilitiesEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH264CapabilitiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH264SessionParametersAddInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH264SessionParametersCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH264PictureInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264PictureInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH264PictureInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH264DpbSlotInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264DpbSlotInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH264MvcInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264MvcInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH264MvcInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH265ProfileInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265ProfileInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH265ProfileInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
            pCopy = allocType<VkVideoDecodeH265CapabilitiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265CapabilitiesEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH265CapabilitiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH265SessionParametersAddInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH265SessionParametersCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH265PictureInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265PictureInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH265PictureInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
            pCopy = allocType<VkVideoDecodeH265DpbSlotInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265DpbSlotInfoEXT));
            copyIndirectData(*static_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
            pCopy = allocType<VkVideoSessionCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoSessionCreateInfoKHR));
            copyIndirectData(*static_cast<VkVideoSessionCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
            pCopy = allocType<VkVideoSessionParametersCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoSessionParametersCreateInfoKHR));
            copyIndirectData(*static_cast<VkVideoSessionParametersCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
            pCopy = allocType<VkVideoSessionParametersUpdateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoSessionParametersUpdateInfoKHR));
            copyIndirectData(*static_cast<VkVideoSessionParametersUpdateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
            pCopy = allocType<VkVideoBeginCodingInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoBeginCodingInfoKHR));
            copyIndirectData(*static_cast<VkVideoBeginCodingInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
            pCopy = allocType<VkVideoEndCodingInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEndCodingInfoKHR));
            copyIndirectData(*static_cast<VkVideoEndCodingInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
            pCopy = allocType<VkVideoCodingControlInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoCodingControlInfoKHR));
            copyIndirectData(*static_cast<VkVideoCodingControlInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
            pCopy = allocType<VkVideoEncodeUsageInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeUsageInfoKHR));
            copyIndirectData(*static_cast<VkVideoEncodeUsageInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
            pCopy = allocType<VkVideoEncodeInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeInfoKHR));
            copyIndirectData(*static_cast<VkVideoEncodeInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
            pCopy = allocType<VkVideoEncodeRateControlInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeRateControlInfoKHR));
            copyIndirectData(*static_cast<VkVideoEncodeRateControlInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR:
            pCopy = allocType<VkVideoEncodeRateControlLayerInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeRateControlLayerInfoKHR));
            copyIndirectData(*static_cast<VkVideoEncodeRateControlLayerInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
            pCopy = allocType<VkVideoEncodeCapabilitiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeCapabilitiesKHR));
            copyIndirectData(*static_cast<VkVideoEncodeCapabilitiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
            pCopy = allocType<VkVideoEncodeH264CapabilitiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264CapabilitiesEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264CapabilitiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264SessionParametersAddInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264SessionParametersCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264DpbSlotInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264DpbSlotInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264VclFrameInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264VclFrameInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264VclFrameInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264ReferenceListsInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264ReferenceListsInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264ReferenceListsInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264EmitPictureParametersInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264EmitPictureParametersInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264EmitPictureParametersInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264ProfileInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264ProfileInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264ProfileInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264NaluSliceInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264NaluSliceInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264NaluSliceInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264RateControlInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264RateControlInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264RateControlInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH264RateControlLayerInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264RateControlLayerInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
            pCopy = allocType<VkVideoEncodeH265CapabilitiesEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265CapabilitiesEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265CapabilitiesEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265SessionParametersAddInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265SessionParametersCreateInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265VclFrameInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265VclFrameInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265VclFrameInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265EmitPictureParametersInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265EmitPictureParametersInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265EmitPictureParametersInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265NaluSliceSegmentInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265NaluSliceSegmentInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265NaluSliceSegmentInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265RateControlInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265RateControlInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265RateControlInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265RateControlLayerInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265RateControlLayerInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265ProfileInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265ProfileInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265ProfileInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265DpbSlotInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265DpbSlotInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT:
            pCopy = allocType<VkVideoEncodeH265ReferenceListsInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265ReferenceListsInfoEXT));
            copyIndirectData(*static_cast<VkVideoEncodeH265ReferenceListsInfoEXT*>(pCopy));
            break;
#endif // defined(VK_ENABLE_BETA_EXTENSIONS)

#if defined(VK_USE_PLATFORM_SCREEN_QNX)

        case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
            pCopy = allocType<VkScreenSurfaceCreateInfoQNX>();
            std::memcpy(pCopy, pNext, sizeof(VkScreenSurfaceCreateInfoQNX));
            copyIndirectData(*static_cast<VkScreenSurfaceCreateInfoQNX*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_SCREEN_QNX)

#if defined(VK_USE_PLATFORM_VI_NN)

        case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
            pCopy = allocType<VkViSurfaceCreateInfoNN>();
            std::memcpy(pCopy, pNext, sizeof(VkViSurfaceCreateInfoNN));
            copyIndirectData(*static_cast<VkViSurfaceCreateInfoNN*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_VI_NN)

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

        case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
            pCopy = allocType<VkWaylandSurfaceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkWaylandSurfaceCreateInfoKHR));
            copyIndirectData(*static_cast<VkWaylandSurfaceCreateInfoKHR*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR)

#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
            pCopy = allocType<VkWin32SurfaceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkWin32SurfaceCreateInfoKHR));
            copyIndirectData(*static_cast<VkWin32SurfaceCreateInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            pCopy = allocType<VkImportMemoryWin32HandleInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMemoryWin32HandleInfoNV));
            copyIndirectData(*static_cast<VkImportMemoryWin32HandleInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            pCopy = allocType<VkExportMemoryWin32HandleInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMemoryWin32HandleInfoNV));
            copyIndirectData(*static_cast<VkExportMemoryWin32HandleInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
            pCopy = allocType<VkWin32KeyedMutexAcquireReleaseInfoNV>();
            std::memcpy(pCopy, pNext, sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV));
            copyIndirectData(*static_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkImportMemoryWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkImportMemoryWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkImportMemoryWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkExportMemoryWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkExportMemoryWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkExportMemoryWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
            pCopy = allocType<VkMemoryWin32HandlePropertiesKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryWin32HandlePropertiesKHR));
            copyIndirectData(*static_cast<VkMemoryWin32HandlePropertiesKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkMemoryGetWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkMemoryGetWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkMemoryGetWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
            pCopy = allocType<VkWin32KeyedMutexAcquireReleaseInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR));
            copyIndirectData(*static_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkImportSemaphoreWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkImportSemaphoreWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkImportSemaphoreWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkExportSemaphoreWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkExportSemaphoreWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkExportSemaphoreWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
            pCopy = allocType<VkD3D12FenceSubmitInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkD3D12FenceSubmitInfoKHR));
            copyIndirectData(*static_cast<VkD3D12FenceSubmitInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkSemaphoreGetWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkSemaphoreGetWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkSemaphoreGetWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkImportFenceWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkImportFenceWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkImportFenceWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkExportFenceWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkExportFenceWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkExportFenceWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
            pCopy = allocType<VkFenceGetWin32HandleInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkFenceGetWin32HandleInfoKHR));
            copyIndirectData(*static_cast<VkFenceGetWin32HandleInfoKHR*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
            pCopy = allocType<VkSurfaceFullScreenExclusiveInfoEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSurfaceFullScreenExclusiveInfoEXT));
            copyIndirectData(*static_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(pCopy));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
            pCopy = allocType<VkSurfaceCapabilitiesFullScreenExclusiveEXT>();
            std::memcpy(pCopy, pNext, sizeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT));
            copyIndirectData(*static_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_WIN32_KHR)

#if defined(VK_USE_PLATFORM_XCB_KHR)

        case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
            pCopy = allocType<VkXcbSurfaceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkXcbSurfaceCreateInfoKHR));
            copyIndirectData(*static_cast<VkXcbSurfaceCreateInfoKHR*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_XCB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_KHR)

        case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
            pCopy = allocType<VkXlibSurfaceCreateInfoKHR>();
            std::memcpy(pCopy, pNext, sizeof(VkXlibSurfaceCreateInfoKHR));
            copyIndirectData(*static_cast<VkXlibSurfaceCreateInfoKHR*>(pCopy));
            break;
#endif // defined(VK_USE_PLATFORM_XLIB_KHR)

        default: break;
    }
    return pCopy;
}
} // namespace vk_capture

#endif // VK_CAPTURE_VARIANT_WRAP_HPP_INCLUDED